2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2010-05-09 18:44:11 +02:00
|
|
|
|
|
|
|
#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"
|
2018-05-15 20:17:34 +02:00
|
|
|
#include "device.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);
|
|
|
|
|
2018-02-08 18:58:35 +01:00
|
|
|
r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &path_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
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
|
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.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-05-14 02:29:45 +02:00
|
|
|
}
|
|
|
|
|
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.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-10-12 04:07:43 +02:00
|
|
|
}
|
|
|
|
|
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) {
|
tree-wide: drop redundant _cleanup_ macros (#8810)
This drops a good number of type-specific _cleanup_ macros, and patches
all users to just use the generic ones.
In most recent code we abstained from defining type-specific macros, and
this basically removes all those added already, with the exception of
the really low-level ones.
Having explicit macros for this is not too useful, as the expression
without the extra macro is generally just 2ch wider. We should generally
emphesize generic code, unless there are really good reasons for
specific code, hence let's follow this in this case too.
Note that _cleanup_free_ and similar really low-level, libc'ish, Linux
API'ish macros continue to be defined, only the really high-level OO
ones are dropped. From now on this should really be the rule: for really
low-level stuff, such as memory allocation, fd handling and so one, go
ahead and define explicit per-type macros, but for high-level, specific
program code, just use the generic _cleanup_() macro directly, in order
to keep things simple and as readable as possible for the uninitiated.
Note that before this patch some of the APIs (notable libudev ones) were
already used with the high-level macros at some places and with the
generic _cleanup_ macro at others. With this patch we hence unify on the
latter.
2018-04-25 12:31:45 +02:00
|
|
|
_cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
|
2013-11-25 21:08:39 +01:00
|
|
|
struct stat st;
|
|
|
|
const char *p;
|
2018-06-04 22:52:02 +02:00
|
|
|
int r;
|
2013-11-25 21:08:39 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
|
|
|
|
return 0;
|
|
|
|
|
2018-06-04 22:52:02 +02:00
|
|
|
r = udev_device_new_from_stat_rdev(UNIT(s)->manager->udev, &st, &d);
|
|
|
|
if (r < 0) {
|
|
|
|
log_unit_full(UNIT(s), r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
|
|
|
|
"Failed to allocate udev device for swap %s: %m", s->what);
|
2013-11-25 21:08:39 +01:00
|
|
|
return 0;
|
2018-06-04 22:52:02 +02:00
|
|
|
}
|
2013-11-25 21:08:39 +01:00
|
|
|
|
|
|
|
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 */
|
2017-11-19 17:00:34 +01:00
|
|
|
if (SWAP(u)->from_proc_swaps)
|
|
|
|
r = unit_load_fragment_and_dropin_optional(u);
|
|
|
|
else
|
|
|
|
r = unit_load_fragment_and_dropin(u);
|
2012-09-19 17:38:00 +02:00
|
|
|
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
|
|
|
|
2018-05-31 16:39:31 +02:00
|
|
|
path_simplify(s->what, false);
|
2010-05-09 18:44:11 +02:00
|
|
|
|
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) {
|
tree-wide: drop redundant _cleanup_ macros (#8810)
This drops a good number of type-specific _cleanup_ macros, and patches
all users to just use the generic ones.
In most recent code we abstained from defining type-specific macros, and
this basically removes all those added already, with the exception of
the really low-level ones.
Having explicit macros for this is not too useful, as the expression
without the extra macro is generally just 2ch wider. We should generally
emphesize generic code, unless there are really good reasons for
specific code, hence let's follow this in this case too.
Note that _cleanup_free_ and similar really low-level, libc'ish, Linux
API'ish macros continue to be defined, only the really high-level OO
ones are dropped. From now on this should really be the rule: for really
low-level stuff, such as memory allocation, fd handling and so one, go
ahead and define explicit per-type macros, but for high-level, specific
program code, just use the generic _cleanup_() macro directly, in order
to keep things simple and as readable as possible for the uninitiated.
Note that before this patch some of the APIs (notable libudev ones) were
already used with the high-level macros at some places and with the
generic _cleanup_ macro at others. With this patch we hence unify on the
latter.
2018-04-25 12:31:45 +02:00
|
|
|
_cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
|
2013-11-25 15:26:30 +01:00
|
|
|
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
|
|
|
|
2018-06-04 22:52:02 +02:00
|
|
|
r = udev_device_new_from_stat_rdev(m->udev, &st, &d);
|
|
|
|
if (r < 0) {
|
|
|
|
log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
|
|
|
|
"Failed to allocate udev device for swap %s: %m", device);
|
2013-11-25 15:26:30 +01:00
|
|
|
return 0;
|
2018-06-04 22:52:02 +02:00
|
|
|
}
|
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
|
|
|
|
2018-06-01 19:06:19 +02:00
|
|
|
unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], 0);
|
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
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
if (!IN_SET(new_state, SWAP_DEAD, SWAP_FAILED)) {
|
2016-07-14 12:37:28 +02:00
|
|
|
(void) unit_setup_dynamic_creds(u);
|
2018-02-06 08:00:34 +01:00
|
|
|
(void) unit_setup_exec_runtime(u);
|
|
|
|
}
|
2016-07-14 12:37:28 +02:00
|
|
|
|
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) {
|
2018-02-09 08:36:37 +01:00
|
|
|
char buf[FORMAT_TIMESPAN_MAX];
|
2010-05-09 18:44:11 +02:00
|
|
|
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
|
|
|
|
2018-01-30 09:10:09 +01:00
|
|
|
fprintf(f,
|
|
|
|
"%sTimeoutSec: %s\n",
|
|
|
|
prefix, format_timespan(buf, sizeof(buf), s->timeout_usec, USEC_PER_SEC));
|
|
|
|
|
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) {
|
2017-11-17 16:43:08 +01:00
|
|
|
|
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,
|
2018-07-17 11:47:14 +02:00
|
|
|
.exec_fd = -1,
|
2014-08-23 15:28:37 +02:00
|
|
|
};
|
2017-11-17 16:43:08 +01:00
|
|
|
pid_t pid;
|
|
|
|
int r;
|
2010-10-12 04:07:43 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(c);
|
|
|
|
assert(_pid);
|
|
|
|
|
2017-11-17 16:43:08 +01:00
|
|
|
r = unit_prepare_exec(UNIT(s));
|
2016-07-14 12:37:28 +02:00
|
|
|
if (r < 0)
|
2017-11-17 16:43:08 +01:00
|
|
|
return r;
|
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 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);
|
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
|
2013-11-27 20:23:18 +01:00
|
|
|
|
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);
|
|
|
|
|
2017-11-24 22:02:22 +01:00
|
|
|
unit_warn_leftover_processes(UNIT(s));
|
|
|
|
|
2010-10-12 04:07:43 +02:00
|
|
|
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;
|
2018-07-17 19:36:46 +02:00
|
|
|
exec_command_reset_status_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
|
2017-11-17 16:43:08 +01:00
|
|
|
|
|
|
|
u->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);
|
|
|
|
}
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
_pure_ static bool swap_may_gc(Unit *u) {
|
2010-05-09 18:44:11 +02:00
|
|
|
Swap *s = SWAP(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
if (s->from_proc_swaps)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
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();
|
|
|
|
|
2018-06-04 18:06:05 +02:00
|
|
|
device_found_node(m, d, DEVICE_FOUND_SWAP, DEVICE_FOUND_SWAP);
|
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)
|
2018-06-04 18:06:05 +02:00
|
|
|
device_found_node(m, swap->what, 0, DEVICE_FOUND_SWAP);
|
2015-02-27 21:55:08 +01:00
|
|
|
|
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;
|
2018-05-14 07:13:57 +02:00
|
|
|
_cleanup_set_free_ Set *set = NULL;
|
2010-11-14 23:47:53 +01:00
|
|
|
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)
|
2018-05-11 18:43:40 +02:00
|
|
|
return r;
|
2013-11-25 15:26:30 +01:00
|
|
|
}
|
2010-11-14 23:47:53 +01:00
|
|
|
|
2018-05-11 18:43:40 +02:00
|
|
|
*_set = TAKE_PTR(set);
|
2010-11-14 23:47:53 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
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);
|
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)
|
2018-06-05 20:57:08 +02:00
|
|
|
log_debug_errno(errno, "Not swap enabled, skipping enumeration.");
|
2015-11-10 20:36:37 +01:00
|
|
|
else
|
2018-06-05 20:57:08 +02:00
|
|
|
log_warning_errno(errno, "Failed to open /proc/swaps, ignoring: %m");
|
2015-11-10 20:36:37 +01:00
|
|
|
|
|
|
|
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. */
|
2018-01-23 18:13:01 +01:00
|
|
|
r = sd_event_source_set_priority(m->swap_event_source, SD_EVENT_PRIORITY_NORMAL-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,
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
.may_gc = swap_may_gc,
|
2010-05-09 18:44:11 +02:00
|
|
|
|
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
|
|
|
};
|