2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2010-05-09 18:44:11 +02: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-05-09 18:44:11 +02: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-05-09 18:44:11 +02:00
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-05-09 18:44:11 +02:00
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/epoll.h>
|
|
|
|
#include <sys/stat.h>
|
2015-10-23 18:52:53 +02:00
|
|
|
#include <unistd.h>
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2015-11-17 06:52:45 +01:00
|
|
|
#include "libudev.h"
|
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2010-05-09 18:44:11 +02:00
|
|
|
#include "dbus-swap.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "escape.h"
|
2011-01-20 18:22:03 +01:00
|
|
|
#include "exit-status.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "fd-util.h"
|
2016-11-07 16:14:59 +01:00
|
|
|
#include "format-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "fstab-util.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2012-05-07 21:36:12 +02:00
|
|
|
#include "path-util.h"
|
2015-10-27 14:24:58 +01:00
|
|
|
#include "process-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "special.h"
|
2015-10-26 22:31:05 +01:00
|
|
|
#include "string-table.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "string-util.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "swap.h"
|
2013-11-25 15:26:30 +01:00
|
|
|
#include "udev-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "unit-name.h"
|
|
|
|
#include "unit.h"
|
|
|
|
#include "virt.h"
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
|
|
|
|
[SWAP_DEAD] = UNIT_INACTIVE,
|
2010-10-12 04:07:43 +02:00
|
|
|
[SWAP_ACTIVATING] = UNIT_ACTIVATING,
|
2013-11-25 15:26:30 +01:00
|
|
|
[SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
|
2010-05-09 18:44:11 +02:00
|
|
|
[SWAP_ACTIVE] = UNIT_ACTIVE,
|
2010-10-12 04:07:43 +02:00
|
|
|
[SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
|
|
|
|
[SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
|
|
|
|
[SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
|
2010-08-31 00:23:34 +02:00
|
|
|
[SWAP_FAILED] = UNIT_FAILED
|
2010-05-09 18:44:11 +02:00
|
|
|
};
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
|
|
|
|
static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
|
2017-09-25 19:57:52 +02:00
|
|
|
static bool SWAP_STATE_WITH_PROCESS(SwapState state) {
|
|
|
|
return IN_SET(state,
|
|
|
|
SWAP_ACTIVATING,
|
|
|
|
SWAP_ACTIVATING_DONE,
|
|
|
|
SWAP_DEACTIVATING,
|
|
|
|
SWAP_DEACTIVATING_SIGTERM,
|
|
|
|
SWAP_DEACTIVATING_SIGKILL);
|
|
|
|
}
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
static void swap_unset_proc_swaps(Swap *s) {
|
2013-11-25 21:08:39 +01:00
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (!s->from_proc_swaps)
|
|
|
|
return;
|
|
|
|
|
2015-09-08 18:43:11 +02:00
|
|
|
s->parameters_proc_swaps.what = mfree(s->parameters_proc_swaps.what);
|
2013-11-25 21:08:39 +01:00
|
|
|
|
|
|
|
s->from_proc_swaps = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_set_devnode(Swap *s, const char *devnode) {
|
2012-09-19 10:52:11 +02:00
|
|
|
Hashmap *swaps;
|
2013-11-25 15:26:30 +01:00
|
|
|
Swap *first;
|
2013-11-25 21:08:39 +01:00
|
|
|
int r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops);
|
2013-11-25 21:08:39 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
swaps = UNIT(s)->manager->swaps_by_devnode;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
if (s->devnode) {
|
|
|
|
first = hashmap_get(swaps, s->devnode);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
LIST_REMOVE(same_devnode, first, s);
|
|
|
|
if (first)
|
|
|
|
hashmap_replace(swaps, first->devnode, first);
|
|
|
|
else
|
|
|
|
hashmap_remove(swaps, s->devnode);
|
2013-11-25 15:26:30 +01:00
|
|
|
|
2015-09-08 18:43:11 +02:00
|
|
|
s->devnode = mfree(s->devnode);
|
2013-11-25 21:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (devnode) {
|
|
|
|
s->devnode = strdup(devnode);
|
|
|
|
if (!s->devnode)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
first = hashmap_get(swaps, s->devnode);
|
|
|
|
LIST_PREPEND(same_devnode, first, s);
|
|
|
|
|
|
|
|
return hashmap_replace(swaps, first->devnode, first);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
2011-11-19 02:47:09 +01:00
|
|
|
static void swap_init(Unit *u) {
|
2010-05-09 23:41:03 +02:00
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
2012-01-15 12:25:20 +01:00
|
|
|
assert(UNIT(s)->load_state == UNIT_STUB);
|
2010-05-09 23:41:03 +02:00
|
|
|
|
2013-11-04 17:47:43 +01:00
|
|
|
s->timeout_usec = u->manager->default_timeout_start_usec;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
s->exec_context.std_output = u->manager->default_std_output;
|
|
|
|
s->exec_context.std_error = u->manager->default_std_error;
|
2014-02-24 23:50:10 +01:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
|
2011-04-14 03:55:03 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
u->ignore_on_isolate = true;
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void swap_unwatch_control_pid(Swap *s) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->control_pid <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
unit_unwatch_pid(UNIT(s), s->control_pid);
|
|
|
|
s->control_pid = 0;
|
2010-05-09 23:41:03 +02:00
|
|
|
}
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
static void swap_done(Unit *u) {
|
|
|
|
Swap *s = SWAP(u);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
assert(s);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
swap_unset_proc_swaps(s);
|
2013-11-25 21:08:39 +01:00
|
|
|
swap_set_devnode(s, NULL);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2015-09-08 18:43:11 +02:00
|
|
|
s->what = mfree(s->what);
|
|
|
|
s->parameters_fragment.what = mfree(s->parameters_fragment.what);
|
|
|
|
s->parameters_fragment.options = mfree(s->parameters_fragment.options);
|
2014-09-24 14:29:05 +02:00
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime);
|
2010-10-12 04:07:43 +02:00
|
|
|
exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
|
|
|
|
s->control_command = NULL;
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_unref(&s->dynamic_creds);
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
swap_unwatch_control_pid(s);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
|
|
|
|
}
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
static int swap_arm_timer(Swap *s, usec_t usec) {
|
2013-11-19 21:12:59 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->timer_event_source) {
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = sd_event_source_set_time(s->timer_event_source, usec);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
|
|
|
|
}
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
if (usec == USEC_INFINITY)
|
|
|
|
return 0;
|
|
|
|
|
2015-04-29 16:05:32 +02:00
|
|
|
r = sd_event_add_time(
|
2014-03-24 02:49:09 +01:00
|
|
|
UNIT(s)->manager->event,
|
|
|
|
&s->timer_event_source,
|
|
|
|
CLOCK_MONOTONIC,
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
usec, 0,
|
2014-03-24 02:49:09 +01:00
|
|
|
swap_dispatch_timer, s);
|
2015-04-29 16:05:32 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
(void) sd_event_source_set_description(s->timer_event_source, "swap-timer");
|
|
|
|
|
|
|
|
return 0;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int swap_add_device_dependencies(Swap *s) {
|
2010-08-25 20:37:04 +02:00
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (!s->what)
|
|
|
|
return 0;
|
|
|
|
|
2014-10-28 17:27:38 +01:00
|
|
|
if (!s->from_fragment)
|
|
|
|
return 0;
|
|
|
|
|
2010-11-22 21:06:38 +01:00
|
|
|
if (is_device_path(s->what))
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_node_dependency(UNIT(s), s->what, MANAGER_IS_SYSTEM(UNIT(s)->manager), UNIT_BINDS_TO, UNIT_DEPENDENCY_FILE);
|
2010-11-22 21:06:38 +01:00
|
|
|
else
|
|
|
|
/* File based swap devices need to be ordered after
|
2012-04-24 16:42:42 +02:00
|
|
|
* systemd-remount-fs.service, since they might need a
|
2010-11-22 21:06:38 +01:00
|
|
|
* writable file system. */
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true, UNIT_DEPENDENCY_FILE);
|
2010-08-25 20:37:04 +02:00
|
|
|
}
|
|
|
|
|
2010-07-12 22:55:27 +02:00
|
|
|
static int swap_add_default_dependencies(Swap *s) {
|
2015-11-23 11:14:10 +01:00
|
|
|
int r;
|
|
|
|
|
2010-07-12 22:55:27 +02:00
|
|
|
assert(s);
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
if (!UNIT(s)->default_dependencies)
|
|
|
|
return 0;
|
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (!MANAGER_IS_SYSTEM(UNIT(s)->manager))
|
2012-05-22 19:23:33 +02:00
|
|
|
return 0;
|
2010-07-12 22:55:27 +02:00
|
|
|
|
2015-09-07 13:42:47 +02:00
|
|
|
if (detect_container() > 0)
|
2012-08-24 23:07:03 +02:00
|
|
|
return 0;
|
|
|
|
|
2015-11-23 11:14:10 +01:00
|
|
|
/* swap units generated for the swap dev links are missing the
|
|
|
|
* ordering dep against the swap target. */
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SWAP_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
|
2015-11-23 11:14:10 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
|
2010-07-12 22:55:27 +02:00
|
|
|
}
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
static int swap_verify(Swap *s) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *e = NULL;
|
2015-04-30 20:21:00 +02:00
|
|
|
int r;
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(s)->load_state != UNIT_LOADED)
|
2013-11-25 15:26:30 +01:00
|
|
|
return 0;
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(s->what, ".swap", &e);
|
|
|
|
if (r < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
return log_unit_error_errno(UNIT(s), r, "Failed to generate unit name from path: %m");
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_has_name(UNIT(s), e)) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(s), "Value of What= and unit name do not match, not loading.");
|
2010-05-14 02:29:45 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-19 23:47:10 +02:00
|
|
|
if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(s), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.");
|
2010-10-12 04:07:43 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
static int swap_load_devnode(Swap *s) {
|
|
|
|
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
|
|
|
|
struct stat st;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
|
|
|
|
if (!d)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
p = udev_device_get_devnode(d);
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return swap_set_devnode(s, p);
|
|
|
|
}
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
static int swap_load(Unit *u) {
|
|
|
|
int r;
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
/* Load a .swap file */
|
2012-09-19 17:38:00 +02:00
|
|
|
r = unit_load_fragment_and_dropin_optional(u);
|
|
|
|
if (r < 0)
|
2010-05-09 18:44:11 +02:00
|
|
|
return r;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->load_state == UNIT_LOADED) {
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(s)->fragment_path)
|
2010-05-14 02:29:45 +02:00
|
|
|
s->from_fragment = true;
|
|
|
|
|
|
|
|
if (!s->what) {
|
|
|
|
if (s->parameters_fragment.what)
|
|
|
|
s->what = strdup(s->parameters_fragment.what);
|
|
|
|
else if (s->parameters_proc_swaps.what)
|
|
|
|
s->what = strdup(s->parameters_proc_swaps.what);
|
2015-04-30 20:21:00 +02:00
|
|
|
else {
|
|
|
|
r = unit_name_to_path(u->id, &s->what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2010-05-14 02:29:45 +02:00
|
|
|
|
|
|
|
if (!s->what)
|
2010-05-09 18:44:11 +02:00
|
|
|
return -ENOMEM;
|
2010-05-14 02:29:45 +02:00
|
|
|
}
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
path_kill_slashes(s->what);
|
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (!UNIT(s)->description) {
|
|
|
|
r = unit_set_description(u, s->what);
|
|
|
|
if (r < 0)
|
2010-05-14 02:29:45 +02:00
|
|
|
return r;
|
2013-11-25 15:26:30 +01:00
|
|
|
}
|
2010-05-14 02:29:45 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_require_mounts_for(UNIT(s), s->what, UNIT_DEPENDENCY_IMPLICIT);
|
2012-09-19 17:38:00 +02:00
|
|
|
if (r < 0)
|
2010-05-09 18:44:11 +02:00
|
|
|
return r;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = swap_add_device_dependencies(s);
|
2012-09-19 17:38:00 +02:00
|
|
|
if (r < 0)
|
2010-05-13 03:07:16 +02:00
|
|
|
return r;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
r = swap_load_devnode(s);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-03-19 20:40:05 +01:00
|
|
|
r = unit_patch_contexts(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = unit_add_exec_dependencies(u, &s->exec_context);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-08-28 17:36:39 +02:00
|
|
|
r = unit_set_default_slice(u);
|
2013-06-17 21:33:26 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
r = swap_add_default_dependencies(s);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return swap_verify(s);
|
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
static int swap_setup_unit(
|
2010-05-14 02:29:45 +02:00
|
|
|
Manager *m,
|
|
|
|
const char *what,
|
2010-10-12 04:07:43 +02:00
|
|
|
const char *what_proc_swaps,
|
2010-05-14 02:29:45 +02:00
|
|
|
int priority,
|
2010-10-12 04:07:43 +02:00
|
|
|
bool set_flags) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *e = NULL;
|
2010-06-02 18:54:50 +02:00
|
|
|
bool delete = false;
|
2013-11-25 15:26:30 +01:00
|
|
|
Unit *u = NULL;
|
2010-05-09 18:44:11 +02:00
|
|
|
int r;
|
2010-05-14 02:29:45 +02:00
|
|
|
SwapParameters *p;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(what);
|
2012-05-22 19:23:33 +02:00
|
|
|
assert(what_proc_swaps);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(what, ".swap", &e);
|
|
|
|
if (r < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
return log_unit_error_errno(u, r, "Failed to generate unit name from path: %m");
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
u = manager_get_unit(m, e);
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
if (u &&
|
2010-10-12 04:07:43 +02:00
|
|
|
SWAP(u)->from_proc_swaps &&
|
2015-02-27 21:55:08 +01:00
|
|
|
!path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps)) {
|
|
|
|
log_error("Swap %s appeared twice with different device paths %s and %s", e, SWAP(u)->parameters_proc_swaps.what, what_proc_swaps);
|
2010-10-12 04:07:43 +02:00
|
|
|
return -EEXIST;
|
2015-02-27 21:55:08 +01:00
|
|
|
}
|
2010-05-14 02:29:45 +02:00
|
|
|
|
|
|
|
if (!u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
delete = true;
|
|
|
|
|
2016-10-25 00:29:05 +02:00
|
|
|
r = unit_new_for_name(m, sizeof(Swap), e, &u);
|
2012-01-15 10:53:49 +01:00
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
SWAP(u)->what = strdup(what);
|
|
|
|
if (!SWAP(u)->what) {
|
2015-02-27 21:55:08 +01:00
|
|
|
r = -ENOMEM;
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
unit_add_to_load_queue(u);
|
2010-05-14 02:29:45 +02:00
|
|
|
} else
|
|
|
|
delete = false;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
p = &SWAP(u)->parameters_proc_swaps;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
if (!p->what) {
|
2013-11-25 15:26:30 +01:00
|
|
|
p->what = strdup(what_proc_swaps);
|
|
|
|
if (!p->what) {
|
|
|
|
r = -ENOMEM;
|
2012-05-22 19:23:33 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
if (set_flags) {
|
|
|
|
SWAP(u)->is_active = true;
|
|
|
|
SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
|
2010-05-14 02:29:45 +02:00
|
|
|
}
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
SWAP(u)->from_proc_swaps = true;
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
p->priority = priority;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
unit_add_to_dbus_queue(u);
|
2010-05-09 18:44:11 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(u, r, "Failed to load swap unit: %m");
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2016-11-28 19:41:20 +01:00
|
|
|
if (delete)
|
2010-05-09 18:44:11 +02:00
|
|
|
unit_free(u);
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
return r;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
static int swap_process_new(Manager *m, const char *device, int prio, bool set_flags) {
|
2013-11-25 15:26:30 +01:00
|
|
|
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
|
|
|
|
struct udev_list_entry *item = NULL, *first = NULL;
|
|
|
|
const char *dn;
|
2010-10-12 04:07:43 +02:00
|
|
|
struct stat st;
|
2013-11-25 15:26:30 +01:00
|
|
|
int r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
r = swap_setup_unit(m, device, device, prio, set_flags);
|
2013-11-25 15:26:30 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
/* If this is a block device, then let's add duplicates for
|
|
|
|
* all other names of this block device */
|
|
|
|
if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
|
|
|
|
return 0;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
|
|
|
|
if (!d)
|
|
|
|
return 0;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
/* Add the main device node */
|
|
|
|
dn = udev_device_get_devnode(d);
|
|
|
|
if (dn && !streq(dn, device))
|
2015-02-27 21:55:08 +01:00
|
|
|
swap_setup_unit(m, dn, device, prio, set_flags);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
/* Add additional units for all symlinks */
|
|
|
|
first = udev_device_get_devlinks_list_entry(d);
|
|
|
|
udev_list_entry_foreach(item, first) {
|
|
|
|
const char *p;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
/* Don't bother with the /dev/block links */
|
|
|
|
p = udev_list_entry_get_name(item);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (streq(p, device))
|
|
|
|
continue;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (path_startswith(p, "/dev/block/"))
|
|
|
|
continue;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (stat(p, &st) >= 0)
|
|
|
|
if (!S_ISBLK(st.st_mode) ||
|
|
|
|
st.st_rdev != udev_device_get_devnum(d))
|
|
|
|
continue;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
swap_setup_unit(m, p, device, prio, set_flags);
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
static void swap_set_state(Swap *s, SwapState state) {
|
|
|
|
SwapState old_state;
|
2015-01-28 00:38:38 +01:00
|
|
|
Swap *other;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
assert(s);
|
|
|
|
|
|
|
|
old_state = s->state;
|
|
|
|
s->state = state;
|
|
|
|
|
2017-09-25 19:57:52 +02:00
|
|
|
if (!SWAP_STATE_WITH_PROCESS(state)) {
|
2013-11-19 21:12:59 +01:00
|
|
|
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
|
2010-10-12 04:07:43 +02:00
|
|
|
swap_unwatch_control_pid(s);
|
|
|
|
s->control_command = NULL;
|
|
|
|
s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
|
|
|
|
}
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
if (state != old_state)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(UNIT(s), "Changed %s -> %s", swap_state_to_string(old_state), swap_state_to_string(state));
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
|
2015-01-28 00:38:38 +01:00
|
|
|
|
|
|
|
/* If there other units for the same device node have a job
|
|
|
|
queued it might be worth checking again if it is runnable
|
|
|
|
now. This is necessary, since swap_start() refuses
|
|
|
|
operation with EAGAIN if there's already another job for
|
|
|
|
the same device node queued. */
|
|
|
|
LIST_FOREACH_OTHERS(same_devnode, other, s)
|
|
|
|
if (UNIT(other)->job)
|
|
|
|
job_add_to_run_queue(UNIT(other)->job);
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2015-04-24 15:27:19 +02:00
|
|
|
static int swap_coldplug(Unit *u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
Swap *s = SWAP(u);
|
|
|
|
SwapState new_state = SWAP_DEAD;
|
2010-10-12 04:07:43 +02:00
|
|
|
int r;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(s->state == SWAP_DEAD);
|
|
|
|
|
|
|
|
if (s->deserialized_state != s->state)
|
|
|
|
new_state = s->deserialized_state;
|
2010-05-14 02:29:45 +02:00
|
|
|
else if (s->from_proc_swaps)
|
2010-05-09 18:44:11 +02:00
|
|
|
new_state = SWAP_ACTIVE;
|
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (new_state == s->state)
|
|
|
|
return 0;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2015-10-27 17:59:45 +01:00
|
|
|
if (s->control_pid > 0 &&
|
|
|
|
pid_is_unwaited(s->control_pid) &&
|
2017-09-25 19:57:52 +02:00
|
|
|
SWAP_STATE_WITH_PROCESS(new_state)) {
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
r = unit_watch_pid(UNIT(s), s->control_pid);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = swap_arm_timer(s, usec_add(u->state_change_timestamp.monotonic, s->timeout_usec));
|
2013-11-25 15:26:30 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
if (!IN_SET(new_state, SWAP_DEAD, SWAP_FAILED))
|
|
|
|
(void) unit_setup_dynamic_creds(u);
|
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
swap_set_state(s, new_state);
|
2010-05-09 18:44:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void swap_dump(Unit *u, FILE *f, const char *prefix) {
|
|
|
|
Swap *s = SWAP(u);
|
2010-05-14 02:29:45 +02:00
|
|
|
SwapParameters *p;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
assert(s);
|
2010-05-14 02:29:45 +02:00
|
|
|
assert(f);
|
|
|
|
|
|
|
|
if (s->from_proc_swaps)
|
|
|
|
p = &s->parameters_proc_swaps;
|
|
|
|
else if (s->from_fragment)
|
|
|
|
p = &s->parameters_fragment;
|
2012-05-24 17:33:50 +02:00
|
|
|
else
|
|
|
|
p = NULL;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
fprintf(f,
|
2010-05-14 02:29:45 +02:00
|
|
|
"%sSwap State: %s\n"
|
2012-02-03 04:47:32 +01:00
|
|
|
"%sResult: %s\n"
|
2010-05-09 18:44:11 +02:00
|
|
|
"%sWhat: %s\n"
|
2010-05-14 02:29:45 +02:00
|
|
|
"%sFrom /proc/swaps: %s\n"
|
|
|
|
"%sFrom fragment: %s\n",
|
2010-05-09 18:44:11 +02:00
|
|
|
prefix, swap_state_to_string(s->state),
|
2012-02-03 04:47:32 +01:00
|
|
|
prefix, swap_result_to_string(s->result),
|
2010-05-09 18:44:11 +02:00
|
|
|
prefix, s->what,
|
2010-05-14 02:29:45 +02:00
|
|
|
prefix, yes_no(s->from_proc_swaps),
|
|
|
|
prefix, yes_no(s->from_fragment));
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
if (s->devnode)
|
|
|
|
fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
|
|
|
|
|
2012-05-24 17:33:50 +02:00
|
|
|
if (p)
|
|
|
|
fprintf(f,
|
|
|
|
"%sPriority: %i\n"
|
2014-10-28 14:24:46 +01:00
|
|
|
"%sOptions: %s\n",
|
2012-05-24 17:33:50 +02:00
|
|
|
prefix, p->priority,
|
2014-10-28 14:24:46 +01:00
|
|
|
prefix, strempty(p->options));
|
2012-05-24 17:33:50 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
if (s->control_pid > 0)
|
|
|
|
fprintf(f,
|
2014-04-25 13:45:15 +02:00
|
|
|
"%sControl PID: "PID_FMT"\n",
|
|
|
|
prefix, s->control_pid);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
exec_context_dump(&s->exec_context, f, prefix);
|
2012-07-19 23:47:10 +02:00
|
|
|
kill_context_dump(&s->kill_context, f, prefix);
|
2017-09-05 19:20:29 +02:00
|
|
|
cgroup_context_dump(&s->cgroup_context, f, prefix);
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
|
|
|
|
pid_t pid;
|
|
|
|
int r;
|
2014-08-23 15:28:37 +02:00
|
|
|
ExecParameters exec_params = {
|
core: rename EXEC_APPLY_PERMISSIONS → EXEC_APPLY_SANDBOXING
"Permissions" was a bit of a misnomer, as it suggests that UNIX file
permission bits are adjusted, which aren't really changed here. Instead,
this is about UNIX credentials such as users or groups, as well as
namespacing, hence let's use a more generic term here, without any
misleading reference to UNIX file permissions: "sandboxing", which shall
refer to all kinds of sandboxing technologies, including UID/GID
dropping, selinux relabelling, namespacing, seccomp, and so on.
2017-08-01 11:30:44 +02:00
|
|
|
.flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
|
2016-07-26 17:40:35 +02:00
|
|
|
.stdin_fd = -1,
|
|
|
|
.stdout_fd = -1,
|
|
|
|
.stderr_fd = -1,
|
2014-08-23 15:28:37 +02:00
|
|
|
};
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(c);
|
|
|
|
assert(_pid);
|
|
|
|
|
2015-03-01 16:24:19 +01:00
|
|
|
(void) unit_realize_cgroup(UNIT(s));
|
2017-09-05 19:27:53 +02:00
|
|
|
if (s->reset_accounting) {
|
|
|
|
(void) unit_reset_cpu_accounting(UNIT(s));
|
|
|
|
(void) unit_reset_ip_accounting(UNIT(s));
|
|
|
|
s->reset_accounting = false;
|
2015-03-01 16:24:19 +01:00
|
|
|
}
|
2013-06-27 04:14:27 +02:00
|
|
|
|
core: implement /run/systemd/units/-based path for passing unit info from PID 1 to journald
And let's make use of it to implement two new unit settings with it:
1. LogLevelMax= is a new per-unit setting that may be used to configure
log priority filtering: set it to LogLevelMax=notice and only
messages of level "notice" and lower (i.e. more important) will be
processed, all others are dropped.
2. LogExtraFields= is a new per-unit setting for configuring per-unit
journal fields, that are implicitly included in every log record
generated by the unit's processes. It takes field/value pairs in the
form of FOO=BAR.
Also, related to this, one exisiting unit setting is ported to this new
facility:
3. The invocation ID is now pulled from /run/systemd/units/ instead of
cgroupfs xattrs. This substantially relaxes requirements of systemd
on the kernel version and the privileges it runs with (specifically,
cgroupfs xattrs are not available in containers, since they are
stored in kernel memory, and hence are unsafe to permit to lesser
privileged code).
/run/systemd/units/ is a new directory, which contains a number of files
and symlinks encoding the above information. PID 1 creates and manages
these files, and journald reads them from there.
Note that this is supposed to be a direct path between PID 1 and the
journal only, due to the special runtime environment the journal runs
in. Normally, today we shouldn't introduce new interfaces that (mis-)use
a file system as IPC framework, and instead just an IPC system, but this
is very hard to do between the journal and PID 1, as long as the IPC
system is a subject PID 1 manages, and itself a client to the journal.
This patch cleans up a couple of types used in journal code:
specifically we switch to size_t for a couple of memory-sizing values,
as size_t is the right choice for everything that is memory.
Fixes: #4089
Fixes: #3041
Fixes: #4441
2017-11-02 19:43:32 +01:00
|
|
|
unit_export_state_files(UNIT(s));
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
r = unit_setup_exec_runtime(UNIT(s));
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
r = unit_setup_dynamic_creds(UNIT(s));
|
|
|
|
if (r < 0)
|
core: add {State,Cache,Log,Configuration}Directory= (#6384)
This introduces {State,Cache,Log,Configuration}Directory= those are
similar to RuntimeDirectory=. They create the directories under
/var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode
specified in {State,Cache,Log,Configuration}DirectoryMode=.
This also fixes #6391.
2017-07-18 14:34:52 +02:00
|
|
|
goto fail;
|
2016-07-14 12:37:28 +02:00
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = swap_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
|
2012-09-19 17:38:00 +02:00
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
2017-08-01 10:53:46 +02:00
|
|
|
manager_set_exec_params(UNIT(s)->manager, &exec_params);
|
2017-08-01 11:02:30 +02:00
|
|
|
unit_set_exec_params(UNIT(s), &exec_params);
|
2014-08-23 15:28:37 +02:00
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
r = exec_spawn(UNIT(s),
|
|
|
|
c,
|
2012-09-19 17:38:00 +02:00
|
|
|
&s->exec_context,
|
2014-08-23 15:28:37 +02:00
|
|
|
&exec_params,
|
2013-11-27 20:23:18 +01:00
|
|
|
s->exec_runtime,
|
2016-07-14 12:37:28 +02:00
|
|
|
&s->dynamic_creds,
|
2012-09-19 17:38:00 +02:00
|
|
|
&pid);
|
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = unit_watch_pid(UNIT(s), pid);
|
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
/* FIXME: we need to do something here */
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
*_pid = pid;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2013-11-19 21:12:59 +01:00
|
|
|
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
|
core: add {State,Cache,Log,Configuration}Directory= (#6384)
This introduces {State,Cache,Log,Configuration}Directory= those are
similar to RuntimeDirectory=. They create the directories under
/var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode
specified in {State,Cache,Log,Configuration}DirectoryMode=.
This also fixes #6391.
2017-07-18 14:34:52 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
return r;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
static void swap_enter_dead(Swap *s, SwapResult f) {
|
2010-05-09 18:44:11 +02:00
|
|
|
assert(s);
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (s->result == SWAP_SUCCESS)
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = f;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2017-09-26 23:35:58 +02:00
|
|
|
if (s->result != SWAP_SUCCESS)
|
|
|
|
log_unit_warning(UNIT(s), "Failed with result '%s'.", swap_result_to_string(s->result));
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
exec_runtime_destroy(s->exec_runtime);
|
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime);
|
|
|
|
|
core: add {State,Cache,Log,Configuration}Directory= (#6384)
This introduces {State,Cache,Log,Configuration}Directory= those are
similar to RuntimeDirectory=. They create the directories under
/var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode
specified in {State,Cache,Log,Configuration}DirectoryMode=.
This also fixes #6391.
2017-07-18 14:34:52 +02:00
|
|
|
exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
|
2014-03-03 17:14:07 +01:00
|
|
|
|
2016-08-01 19:24:40 +02:00
|
|
|
unit_unref_uid_gid(UNIT(s), true);
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_destroy(&s->dynamic_creds);
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
static void swap_enter_active(Swap *s, SwapResult f) {
|
2010-10-12 04:07:43 +02:00
|
|
|
assert(s);
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (s->result == SWAP_SUCCESS)
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = f;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
swap_set_state(s, SWAP_ACTIVE);
|
|
|
|
}
|
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
static void swap_enter_dead_or_active(Swap *s, SwapResult f) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->from_proc_swaps)
|
|
|
|
swap_enter_active(s, f);
|
|
|
|
else
|
|
|
|
swap_enter_dead(s, f);
|
|
|
|
}
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
|
2010-05-09 18:44:11 +02:00
|
|
|
int r;
|
2017-05-17 12:43:59 +02:00
|
|
|
KillOperation kop;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
assert(s);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (s->result == SWAP_SUCCESS)
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = f;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
if (state == SWAP_DEACTIVATING_SIGTERM)
|
2017-05-17 12:43:59 +02:00
|
|
|
kop = KILL_TERMINATE;
|
|
|
|
else
|
|
|
|
kop = KILL_KILL;
|
|
|
|
|
|
|
|
r = unit_kill_context(UNIT(s), &s->kill_context, kop, -1, s->control_pid, false);
|
2013-01-26 05:53:30 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-01-26 05:53:30 +01:00
|
|
|
if (r > 0) {
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = swap_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
|
2012-09-19 17:38:00 +02:00
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
swap_set_state(s, state);
|
2017-09-25 19:53:19 +02:00
|
|
|
} else if (state == SWAP_DEACTIVATING_SIGTERM && s->kill_context.send_sigkill)
|
2014-01-29 14:58:04 +01:00
|
|
|
swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
|
|
|
|
else
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, SWAP_SUCCESS);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void swap_enter_activating(Swap *s) {
|
2015-05-25 12:11:23 +02:00
|
|
|
_cleanup_free_ char *opts = NULL;
|
|
|
|
int r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
s->control_command_id = SWAP_EXEC_ACTIVATE;
|
|
|
|
s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2014-09-24 14:29:05 +02:00
|
|
|
if (s->from_fragment) {
|
2015-05-25 12:11:23 +02:00
|
|
|
int priority = -1;
|
2014-10-28 14:24:46 +01:00
|
|
|
|
2015-05-25 12:11:23 +02:00
|
|
|
r = fstab_find_pri(s->parameters_fragment.options, &priority);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning_errno(r, "Failed to parse swap priority \"%s\", ignoring: %m", s->parameters_fragment.options);
|
|
|
|
else if (r == 1 && s->parameters_fragment.priority >= 0)
|
|
|
|
log_warning("Duplicate swap priority configuration by Priority and Options fields.");
|
|
|
|
|
|
|
|
if (r <= 0 && s->parameters_fragment.priority >= 0) {
|
|
|
|
if (s->parameters_fragment.options)
|
|
|
|
r = asprintf(&opts, "%s,pri=%i", s->parameters_fragment.options, s->parameters_fragment.priority);
|
|
|
|
else
|
|
|
|
r = asprintf(&opts, "pri=%i", s->parameters_fragment.priority);
|
2015-03-14 03:21:46 +01:00
|
|
|
if (r < 0)
|
2015-05-25 12:11:23 +02:00
|
|
|
goto fail;
|
2015-03-14 03:21:46 +01:00
|
|
|
}
|
2014-09-24 14:29:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2015-05-25 12:11:23 +02:00
|
|
|
if (s->parameters_fragment.options || opts) {
|
|
|
|
r = exec_command_append(s->control_command, "-o",
|
|
|
|
opts ? : s->parameters_fragment.options, NULL);
|
2014-09-24 14:29:05 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2014-09-24 14:29:05 +02:00
|
|
|
r = exec_command_append(s->control_command, s->what, NULL);
|
2010-10-12 04:07:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
swap_unwatch_control_pid(s);
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = swap_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
swap_set_state(s, SWAP_ACTIVATING);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to run 'swapon' task: %m");
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
static void swap_enter_deactivating(Swap *s) {
|
2010-10-12 04:07:43 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
s->control_command_id = SWAP_EXEC_DEACTIVATE;
|
|
|
|
s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = exec_command_set(s->control_command,
|
2010-10-12 04:07:43 +02:00
|
|
|
"/sbin/swapoff",
|
|
|
|
s->what,
|
2012-09-19 17:38:00 +02:00
|
|
|
NULL);
|
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
swap_unwatch_control_pid(s);
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = swap_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
if (r < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
swap_set_state(s, SWAP_DEACTIVATING);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to run 'swapoff' task: %m");
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_start(Unit *u) {
|
2015-01-28 00:38:38 +01:00
|
|
|
Swap *s = SWAP(u), *other;
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
int r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
/* We cannot fulfill this request right now, try again later please! */
|
2017-05-17 12:43:59 +02:00
|
|
|
if (IN_SET(s->state,
|
|
|
|
SWAP_DEACTIVATING,
|
|
|
|
SWAP_DEACTIVATING_SIGTERM,
|
2017-09-25 19:53:19 +02:00
|
|
|
SWAP_DEACTIVATING_SIGKILL))
|
2010-10-12 04:07:43 +02:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
/* Already on it! */
|
2010-10-12 04:07:43 +02:00
|
|
|
if (s->state == SWAP_ACTIVATING)
|
|
|
|
return 0;
|
|
|
|
|
2017-05-17 12:43:59 +02:00
|
|
|
assert(IN_SET(s->state, SWAP_DEAD, SWAP_FAILED));
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2015-09-07 13:42:47 +02:00
|
|
|
if (detect_container() > 0)
|
2012-08-24 23:00:13 +02:00
|
|
|
return -EPERM;
|
|
|
|
|
2015-01-28 00:38:38 +01:00
|
|
|
/* If there's a job for another swap unit for the same node
|
|
|
|
* running, then let's not dispatch this one for now, and wait
|
|
|
|
* until that other job has finished. */
|
|
|
|
LIST_FOREACH_OTHERS(same_devnode, other, s)
|
|
|
|
if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
r = unit_start_limit_test(u);
|
|
|
|
if (r < 0) {
|
|
|
|
swap_enter_dead(s, SWAP_FAILURE_START_LIMIT_HIT);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2016-08-30 23:18:46 +02:00
|
|
|
r = unit_acquire_invocation_id(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = SWAP_SUCCESS;
|
2017-09-05 19:27:53 +02:00
|
|
|
s->reset_accounting = true;
|
2015-03-01 16:24:19 +01:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
swap_enter_activating(s);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_stop(Unit *u) {
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
switch (s->state) {
|
|
|
|
|
|
|
|
case SWAP_DEACTIVATING:
|
|
|
|
case SWAP_DEACTIVATING_SIGTERM:
|
|
|
|
case SWAP_DEACTIVATING_SIGKILL:
|
|
|
|
/* Already on it */
|
2010-10-12 04:07:43 +02:00
|
|
|
return 0;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
case SWAP_ACTIVATING:
|
|
|
|
case SWAP_ACTIVATING_DONE:
|
|
|
|
/* There's a control process pending, directly enter kill mode */
|
|
|
|
swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_SUCCESS);
|
|
|
|
return 0;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
case SWAP_ACTIVE:
|
|
|
|
if (detect_container() > 0)
|
|
|
|
return -EPERM;
|
2012-08-24 23:00:13 +02:00
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_deactivating(s);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Unexpected state.");
|
|
|
|
}
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
|
2012-02-03 04:47:32 +01:00
|
|
|
unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
if (s->control_pid > 0)
|
2014-04-25 13:45:15 +02:00
|
|
|
unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
if (s->control_command_id >= 0)
|
|
|
|
unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
if (streq(key, "state")) {
|
|
|
|
SwapState state;
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
state = swap_state_from_string(value);
|
|
|
|
if (state < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse state value: %s", value);
|
2010-05-09 18:44:11 +02:00
|
|
|
else
|
|
|
|
s->deserialized_state = state;
|
2012-02-03 04:47:32 +01:00
|
|
|
} else if (streq(key, "result")) {
|
|
|
|
SwapResult f;
|
|
|
|
|
|
|
|
f = swap_result_from_string(value);
|
|
|
|
if (f < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse result value: %s", value);
|
2012-02-03 04:47:32 +01:00
|
|
|
else if (f != SWAP_SUCCESS)
|
|
|
|
s->result = f;
|
2010-10-12 04:07:43 +02:00
|
|
|
} else if (streq(key, "control-pid")) {
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
if (parse_pid(value, &pid) < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse control-pid value: %s", value);
|
2010-10-12 04:07:43 +02:00
|
|
|
else
|
|
|
|
s->control_pid = pid;
|
|
|
|
|
|
|
|
} else if (streq(key, "control-command")) {
|
|
|
|
SwapExecCommand id;
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
id = swap_exec_command_from_string(value);
|
|
|
|
if (id < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse exec-command value: %s", value);
|
2010-10-12 04:07:43 +02:00
|
|
|
else {
|
|
|
|
s->control_command_id = id;
|
|
|
|
s->control_command = s->exec_command + id;
|
|
|
|
}
|
2010-05-09 18:44:11 +02:00
|
|
|
} else
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Unknown serialization key: %s", key);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static UnitActiveState swap_active_state(Unit *u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return state_translation_table[SWAP(u)->state];
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static const char *swap_sub_state_to_string(Unit *u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return swap_state_to_string(SWAP(u)->state);
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static bool swap_check_gc(Unit *u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
return s->from_proc_swaps;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
|
|
|
|
Swap *s = SWAP(u);
|
2012-02-03 04:47:32 +01:00
|
|
|
SwapResult f;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(pid >= 0);
|
|
|
|
|
|
|
|
if (pid != s->control_pid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
s->control_pid = 0;
|
|
|
|
|
2016-10-10 22:07:30 +02:00
|
|
|
if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
|
2012-02-03 04:47:32 +01:00
|
|
|
f = SWAP_SUCCESS;
|
|
|
|
else if (code == CLD_EXITED)
|
|
|
|
f = SWAP_FAILURE_EXIT_CODE;
|
|
|
|
else if (code == CLD_KILLED)
|
|
|
|
f = SWAP_FAILURE_SIGNAL;
|
|
|
|
else if (code == CLD_DUMPED)
|
|
|
|
f = SWAP_FAILURE_CORE_DUMP;
|
|
|
|
else
|
|
|
|
assert_not_reached("Unknown code");
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (s->result == SWAP_SUCCESS)
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = f;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
if (s->control_command) {
|
2011-05-18 01:07:31 +02:00
|
|
|
exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
|
2012-02-03 04:47:32 +01:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
s->control_command = NULL;
|
|
|
|
s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
|
|
|
|
}
|
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_full(u, f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
|
|
|
|
"Swap process exited, code=%s status=%i", sigchld_code_to_string(code), status);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
switch (s->state) {
|
|
|
|
|
|
|
|
case SWAP_ACTIVATING:
|
2013-11-25 15:26:30 +01:00
|
|
|
case SWAP_ACTIVATING_DONE:
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
if (f == SWAP_SUCCESS || s->from_proc_swaps)
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_active(s, f);
|
2010-10-12 04:07:43 +02:00
|
|
|
else
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_dead(s, f);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SWAP_DEACTIVATING:
|
|
|
|
case SWAP_DEACTIVATING_SIGKILL:
|
|
|
|
case SWAP_DEACTIVATING_SIGTERM:
|
|
|
|
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, f);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Uh, control process died at wrong time.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Notify clients about changed exit status */
|
|
|
|
unit_add_to_dbus_queue(u);
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
|
|
|
|
Swap *s = SWAP(userdata);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(s->timer_event_source == source);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
switch (s->state) {
|
|
|
|
|
|
|
|
case SWAP_ACTIVATING:
|
2013-11-25 15:26:30 +01:00
|
|
|
case SWAP_ACTIVATING_DONE:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning(UNIT(s), "Activation timed out. Stopping.");
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SWAP_DEACTIVATING:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning(UNIT(s), "Deactivation timed out. Stopping.");
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SWAP_DEACTIVATING_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
if (s->kill_context.send_sigkill) {
|
2017-09-25 19:53:19 +02:00
|
|
|
log_unit_warning(UNIT(s), "Swap process timed out. Killing.");
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
} else {
|
2017-09-25 19:53:19 +02:00
|
|
|
log_unit_warning(UNIT(s), "Swap process timed out. Skipping SIGKILL. Ignoring.");
|
|
|
|
swap_enter_dead_or_active(s, SWAP_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
}
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SWAP_DEACTIVATING_SIGKILL:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning(UNIT(s), "Swap process still around after SIGKILL. Ignoring.");
|
2017-09-25 19:53:19 +02:00
|
|
|
swap_enter_dead_or_active(s, SWAP_FAILURE_TIMEOUT);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Timeout at wrong time.");
|
|
|
|
}
|
2013-11-19 21:12:59 +01:00
|
|
|
|
|
|
|
return 0;
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swap_load_proc_swaps(Manager *m, bool set_flags) {
|
|
|
|
unsigned i;
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
rewind(m->proc_swaps);
|
2010-05-10 03:34:31 +02:00
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
(void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
for (i = 1;; i++) {
|
2013-09-17 22:12:16 +02:00
|
|
|
_cleanup_free_ char *dev = NULL, *d = NULL;
|
2010-05-09 18:44:11 +02:00
|
|
|
int prio = 0, k;
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
k = fscanf(m->proc_swaps,
|
|
|
|
"%ms " /* device/file */
|
|
|
|
"%*s " /* type of swap */
|
|
|
|
"%*s " /* swap size */
|
|
|
|
"%*s " /* used */
|
|
|
|
"%i\n", /* priority */
|
|
|
|
&dev, &prio);
|
|
|
|
if (k != 2) {
|
2010-05-09 18:44:11 +02:00
|
|
|
if (k == EOF)
|
2010-05-14 02:29:45 +02:00
|
|
|
break;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
log_warning("Failed to parse /proc/swaps:%u.", i);
|
2010-10-12 04:07:43 +02:00
|
|
|
continue;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2015-04-06 20:11:41 +02:00
|
|
|
if (cunescape(dev, UNESCAPE_RELAX, &d) < 0)
|
2015-02-27 21:55:08 +01:00
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
device_found_node(m, d, true, DEVICE_FOUND_SWAP, set_flags);
|
2010-05-14 02:29:45 +02:00
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
k = swap_process_new(m, d, prio, set_flags);
|
2010-05-09 18:44:11 +02:00
|
|
|
if (k < 0)
|
2010-10-12 04:07:43 +02:00
|
|
|
r = k;
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-10-18 23:09:09 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(revents & EPOLLPRI);
|
2010-10-18 23:09:09 +02:00
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = swap_load_proc_swaps(m, true);
|
|
|
|
if (r < 0) {
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "Failed to reread /proc/swaps: %m");
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
/* Reset flags, just in case, for late calls */
|
2012-01-15 12:37:16 +01:00
|
|
|
LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
|
|
|
|
Swap *swap = SWAP(u);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
swap->is_active = swap->just_activated = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
manager_dispatch_load_queue(m);
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
|
|
|
|
Swap *swap = SWAP(u);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
if (!swap->is_active) {
|
|
|
|
/* This has just been deactivated */
|
|
|
|
|
|
|
|
swap_unset_proc_swaps(swap);
|
|
|
|
|
|
|
|
switch (swap->state) {
|
|
|
|
|
|
|
|
case SWAP_ACTIVE:
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_dead(swap, SWAP_SUCCESS);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2013-11-25 15:26:30 +01:00
|
|
|
/* Fire again */
|
2010-10-12 04:07:43 +02:00
|
|
|
swap_set_state(swap, swap->state);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
if (swap->what)
|
|
|
|
device_found_node(m, swap->what, false, DEVICE_FOUND_SWAP, true);
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
} else if (swap->just_activated) {
|
|
|
|
|
|
|
|
/* New swap entry */
|
|
|
|
|
|
|
|
switch (swap->state) {
|
|
|
|
|
|
|
|
case SWAP_DEAD:
|
|
|
|
case SWAP_FAILED:
|
2016-08-30 23:18:46 +02:00
|
|
|
(void) unit_acquire_invocation_id(UNIT(swap));
|
2012-02-03 04:47:32 +01:00
|
|
|
swap_enter_active(swap, SWAP_SUCCESS);
|
2010-10-12 04:07:43 +02:00
|
|
|
break;
|
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
case SWAP_ACTIVATING:
|
|
|
|
swap_set_state(swap, SWAP_ACTIVATING_DONE);
|
|
|
|
break;
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
default:
|
|
|
|
/* Nothing really changed, but let's
|
|
|
|
* issue an notification call
|
|
|
|
* nonetheless, in case somebody is
|
|
|
|
* waiting for this. */
|
|
|
|
swap_set_state(swap, swap->state);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the flags for later calls */
|
|
|
|
swap->is_active = swap->just_activated = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Unit *swap_following(Unit *u) {
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
Swap *other, *first = NULL;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2014-09-28 16:37:52 +02:00
|
|
|
/* If the user configured the swap through /etc/fstab or
|
|
|
|
* a device unit, follow that. */
|
|
|
|
|
|
|
|
if (s->from_fragment)
|
2010-10-12 04:07:43 +02:00
|
|
|
return NULL;
|
|
|
|
|
2015-01-28 00:37:11 +01:00
|
|
|
LIST_FOREACH_OTHERS(same_devnode, other, s)
|
2014-09-28 16:37:52 +02:00
|
|
|
if (other->from_fragment)
|
|
|
|
return UNIT(other);
|
|
|
|
|
2014-08-03 07:11:12 +02:00
|
|
|
/* Otherwise, make everybody follow the unit that's named after
|
2014-09-28 16:37:52 +02:00
|
|
|
* the swap device in the kernel */
|
|
|
|
|
|
|
|
if (streq_ptr(s->what, s->devnode))
|
|
|
|
return NULL;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
LIST_FOREACH_AFTER(same_devnode, other, s)
|
|
|
|
if (streq_ptr(other->what, other->devnode))
|
2010-10-12 04:07:43 +02:00
|
|
|
return UNIT(other);
|
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
LIST_FOREACH_BEFORE(same_devnode, other, s) {
|
|
|
|
if (streq_ptr(other->what, other->devnode))
|
2010-10-12 04:07:43 +02:00
|
|
|
return UNIT(other);
|
|
|
|
|
|
|
|
first = other;
|
|
|
|
}
|
|
|
|
|
2014-09-28 16:37:52 +02:00
|
|
|
/* Fall back to the first on the list */
|
2010-10-12 04:07:43 +02:00
|
|
|
return UNIT(first);
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2010-11-14 23:47:53 +01:00
|
|
|
static int swap_following_set(Unit *u, Set **_set) {
|
2013-11-25 15:26:30 +01:00
|
|
|
Swap *s = SWAP(u), *other;
|
2010-11-14 23:47:53 +01:00
|
|
|
Set *set;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(_set);
|
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
if (LIST_JUST_US(same_devnode, s)) {
|
2010-11-14 23:47:53 +01:00
|
|
|
*_set = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
set = set_new(NULL);
|
2013-11-25 15:26:30 +01:00
|
|
|
if (!set)
|
2010-11-14 23:47:53 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-01-28 00:37:11 +01:00
|
|
|
LIST_FOREACH_OTHERS(same_devnode, other, s) {
|
2013-11-25 15:26:30 +01:00
|
|
|
r = set_put(set, other);
|
|
|
|
if (r < 0)
|
2010-11-14 23:47:53 +01:00
|
|
|
goto fail;
|
2013-11-25 15:26:30 +01:00
|
|
|
}
|
2010-11-14 23:47:53 +01:00
|
|
|
|
|
|
|
*_set = set;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
set_free(set);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
static void swap_shutdown(Manager *m) {
|
|
|
|
assert(m);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->swap_event_source = sd_event_source_unref(m->swap_event_source);
|
|
|
|
|
2015-09-09 15:20:10 +02:00
|
|
|
m->proc_swaps = safe_fclose(m->proc_swaps);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2015-09-09 23:12:07 +02:00
|
|
|
m->swaps_by_devnode = hashmap_free(m->swaps_by_devnode);
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2015-11-10 20:36:37 +01:00
|
|
|
static void swap_enumerate(Manager *m) {
|
2010-05-09 18:44:11 +02:00
|
|
|
int r;
|
2013-11-25 21:08:39 +01:00
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
assert(m);
|
|
|
|
|
2010-10-18 23:09:09 +02:00
|
|
|
if (!m->proc_swaps) {
|
2012-09-19 17:38:00 +02:00
|
|
|
m->proc_swaps = fopen("/proc/swaps", "re");
|
2015-11-10 20:36:37 +01:00
|
|
|
if (!m->proc_swaps) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
log_debug("Not swap enabled, skipping enumeration");
|
|
|
|
else
|
|
|
|
log_error_errno(errno, "Failed to open /proc/swaps: %m");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
2010-10-18 23:09:09 +02:00
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to watch /proc/swaps: %m");
|
2013-11-25 15:35:10 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2013-11-25 15:35:10 +01:00
|
|
|
|
|
|
|
/* Dispatch this before we dispatch SIGCHLD, so that
|
|
|
|
* we always get the events from /proc/swaps before
|
|
|
|
* the SIGCHLD of /sbin/swapon. */
|
|
|
|
r = sd_event_source_set_priority(m->swap_event_source, -10);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to change /proc/swaps priority: %m");
|
2013-11-19 21:12:59 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2015-04-29 16:05:32 +02:00
|
|
|
|
|
|
|
(void) sd_event_source_set_description(m->swap_event_source, "swap-proc");
|
2010-10-18 23:09:09 +02:00
|
|
|
}
|
|
|
|
|
2012-09-19 17:38:00 +02:00
|
|
|
r = swap_load_proc_swaps(m, false);
|
|
|
|
if (r < 0)
|
2013-11-19 21:12:59 +01:00
|
|
|
goto fail;
|
|
|
|
|
2015-11-10 20:36:37 +01:00
|
|
|
return;
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
fail:
|
|
|
|
swap_shutdown(m);
|
2010-05-09 18:44:11 +02:00
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
int swap_process_device_new(Manager *m, struct udev_device *dev) {
|
2013-11-25 21:08:39 +01:00
|
|
|
struct udev_list_entry *item = NULL, *first = NULL;
|
|
|
|
_cleanup_free_ char *e = NULL;
|
|
|
|
const char *dn;
|
2017-05-16 21:27:44 +02:00
|
|
|
Unit *u;
|
2013-11-25 21:08:39 +01:00
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(dev);
|
|
|
|
|
|
|
|
dn = udev_device_get_devnode(dev);
|
|
|
|
if (!dn)
|
|
|
|
return 0;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(dn, ".swap", &e);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-11-25 21:08:39 +01:00
|
|
|
|
2017-05-16 21:27:44 +02:00
|
|
|
u = manager_get_unit(m, e);
|
|
|
|
if (u)
|
|
|
|
r = swap_set_devnode(SWAP(u), dn);
|
2013-11-25 21:08:39 +01:00
|
|
|
|
|
|
|
first = udev_device_get_devlinks_list_entry(dev);
|
|
|
|
udev_list_entry_foreach(item, first) {
|
|
|
|
_cleanup_free_ char *n = NULL;
|
2015-04-30 20:21:00 +02:00
|
|
|
int q;
|
2013-11-25 21:08:39 +01:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
q = unit_name_from_path(udev_list_entry_get_name(item), ".swap", &n);
|
|
|
|
if (q < 0)
|
|
|
|
return q;
|
2013-11-25 21:08:39 +01:00
|
|
|
|
2017-05-16 21:27:44 +02:00
|
|
|
u = manager_get_unit(m, n);
|
|
|
|
if (u) {
|
|
|
|
q = swap_set_devnode(SWAP(u), dn);
|
2013-11-25 21:08:39 +01:00
|
|
|
if (q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
int swap_process_device_remove(Manager *m, struct udev_device *dev) {
|
2013-11-25 21:08:39 +01:00
|
|
|
const char *dn;
|
|
|
|
int r = 0;
|
|
|
|
Swap *s;
|
|
|
|
|
|
|
|
dn = udev_device_get_devnode(dev);
|
|
|
|
if (!dn)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
|
|
|
|
int q;
|
|
|
|
|
|
|
|
q = swap_set_devnode(s, NULL);
|
|
|
|
if (q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
static void swap_reset_failed(Unit *u) {
|
2010-07-18 04:58:01 +02:00
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
if (s->state == SWAP_FAILED)
|
2010-07-18 04:58:01 +02:00
|
|
|
swap_set_state(s, SWAP_DEAD);
|
2010-10-12 04:07:43 +02:00
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
s->result = SWAP_SUCCESS;
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
|
2013-03-02 22:31:09 +01:00
|
|
|
return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
|
2010-10-22 16:11:50 +02:00
|
|
|
}
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
static int swap_get_timeout(Unit *u, usec_t *timeout) {
|
2014-01-27 06:57:34 +01:00
|
|
|
Swap *s = SWAP(u);
|
2016-02-04 00:35:43 +01:00
|
|
|
usec_t t;
|
2014-01-27 06:57:34 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!s->timer_event_source)
|
|
|
|
return 0;
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
r = sd_event_source_get_time(s->timer_event_source, &t);
|
2014-01-27 06:57:34 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2016-02-04 00:35:43 +01:00
|
|
|
if (t == USEC_INFINITY)
|
|
|
|
return 0;
|
2014-01-27 06:57:34 +01:00
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
*timeout = t;
|
2014-01-27 06:57:34 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-30 01:29:00 +02:00
|
|
|
static bool swap_supported(void) {
|
2014-12-12 21:05:32 +01:00
|
|
|
static int supported = -1;
|
|
|
|
|
|
|
|
/* If swap support is not available in the kernel, or we are
|
|
|
|
* running in a container we don't support swap units, and any
|
|
|
|
* attempts to starting one should fail immediately. */
|
|
|
|
|
|
|
|
if (supported < 0)
|
|
|
|
supported =
|
|
|
|
access("/proc/swaps", F_OK) >= 0 &&
|
2015-09-07 13:42:47 +02:00
|
|
|
detect_container() <= 0;
|
2014-12-12 21:05:32 +01:00
|
|
|
|
|
|
|
return supported;
|
|
|
|
}
|
|
|
|
|
2016-04-20 15:28:28 +02:00
|
|
|
static int swap_control_pid(Unit *u) {
|
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
return s->control_pid;
|
|
|
|
}
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
|
|
|
|
[SWAP_EXEC_ACTIVATE] = "ExecActivate",
|
|
|
|
[SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
|
|
|
|
|
2012-02-03 04:47:32 +01:00
|
|
|
static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
|
|
|
|
[SWAP_SUCCESS] = "success",
|
|
|
|
[SWAP_FAILURE_RESOURCES] = "resources",
|
|
|
|
[SWAP_FAILURE_TIMEOUT] = "timeout",
|
|
|
|
[SWAP_FAILURE_EXIT_CODE] = "exit-code",
|
|
|
|
[SWAP_FAILURE_SIGNAL] = "signal",
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
[SWAP_FAILURE_CORE_DUMP] = "core-dump",
|
|
|
|
[SWAP_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
|
2012-02-03 04:47:32 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
const UnitVTable swap_vtable = {
|
2012-01-15 10:53:49 +01:00
|
|
|
.object_size = sizeof(Swap),
|
2013-11-19 21:12:59 +01:00
|
|
|
.exec_context_offset = offsetof(Swap, exec_context),
|
|
|
|
.cgroup_context_offset = offsetof(Swap, cgroup_context),
|
|
|
|
.kill_context_offset = offsetof(Swap, kill_context),
|
2013-11-27 20:23:18 +01:00
|
|
|
.exec_runtime_offset = offsetof(Swap, exec_runtime),
|
2016-07-14 12:37:28 +02:00
|
|
|
.dynamic_creds_offset = offsetof(Swap, dynamic_creds),
|
2012-09-18 11:40:01 +02:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
.sections =
|
|
|
|
"Unit\0"
|
|
|
|
"Swap\0"
|
|
|
|
"Install\0",
|
2013-06-27 04:14:27 +02:00
|
|
|
.private_section = "Swap",
|
2013-01-19 01:01:41 +01:00
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
.init = swap_init,
|
2010-05-09 18:44:11 +02:00
|
|
|
.load = swap_load,
|
2010-05-09 23:41:03 +02:00
|
|
|
.done = swap_done,
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
.coldplug = swap_coldplug,
|
|
|
|
|
|
|
|
.dump = swap_dump,
|
|
|
|
|
|
|
|
.start = swap_start,
|
|
|
|
.stop = swap_stop,
|
|
|
|
|
2010-10-22 16:11:50 +02:00
|
|
|
.kill = swap_kill,
|
|
|
|
|
2014-01-27 06:57:34 +01:00
|
|
|
.get_timeout = swap_get_timeout,
|
|
|
|
|
2010-05-09 18:44:11 +02:00
|
|
|
.serialize = swap_serialize,
|
|
|
|
.deserialize_item = swap_deserialize_item,
|
|
|
|
|
|
|
|
.active_state = swap_active_state,
|
|
|
|
.sub_state_to_string = swap_sub_state_to_string,
|
|
|
|
|
|
|
|
.check_gc = swap_check_gc,
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
.sigchld_event = swap_sigchld_event,
|
|
|
|
|
|
|
|
.reset_failed = swap_reset_failed,
|
|
|
|
|
2016-04-20 15:28:28 +02:00
|
|
|
.control_pid = swap_control_pid,
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
.bus_vtable = bus_swap_vtable,
|
2013-06-27 23:21:21 +02:00
|
|
|
.bus_set_property = bus_swap_set_property,
|
|
|
|
.bus_commit_properties = bus_swap_commit_properties,
|
2010-05-09 18:44:11 +02:00
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
.following = swap_following,
|
2010-11-14 23:47:53 +01:00
|
|
|
.following_set = swap_following_set,
|
2010-07-18 04:58:01 +02:00
|
|
|
|
2010-05-09 23:41:03 +02:00
|
|
|
.enumerate = swap_enumerate,
|
2012-05-13 18:18:54 +02:00
|
|
|
.shutdown = swap_shutdown,
|
2014-12-12 21:05:32 +01:00
|
|
|
.supported = swap_supported,
|
2012-05-13 18:18:54 +02:00
|
|
|
|
|
|
|
.status_message_formats = {
|
|
|
|
.starting_stopping = {
|
|
|
|
[0] = "Activating swap %s...",
|
|
|
|
[1] = "Deactivating swap %s...",
|
|
|
|
},
|
|
|
|
.finished_start_job = {
|
|
|
|
[JOB_DONE] = "Activated swap %s.",
|
|
|
|
[JOB_FAILED] = "Failed to activate swap %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out activating swap %s.",
|
|
|
|
},
|
|
|
|
.finished_stop_job = {
|
|
|
|
[JOB_DONE] = "Deactivated swap %s.",
|
|
|
|
[JOB_FAILED] = "Failed deactivating swap %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out deactivating swap %s.",
|
|
|
|
},
|
|
|
|
},
|
2010-05-09 18:44:11 +02:00
|
|
|
};
|