2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2010-02-03 13:03:47 +01:00
|
|
|
|
2010-01-28 02:44:47 +01:00
|
|
|
#include <errno.h>
|
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "bus-error.h"
|
|
|
|
#include "bus-util.h"
|
2010-05-24 01:45:54 +02:00
|
|
|
#include "dbus-timer.h"
|
2015-10-26 21:16:26 +01:00
|
|
|
#include "fs-util.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2015-11-18 13:37:30 +01:00
|
|
|
#include "random-util.h"
|
2018-10-17 20:40:09 +02:00
|
|
|
#include "serialize.h"
|
2010-07-03 19:48:33 +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 22:32:30 +01:00
|
|
|
#include "timer.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "unit-name.h"
|
|
|
|
#include "unit.h"
|
2015-10-25 22:32:30 +01:00
|
|
|
#include "user-util.h"
|
2015-11-07 15:09:31 +01:00
|
|
|
#include "virt.h"
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
|
|
|
|
[TIMER_DEAD] = UNIT_INACTIVE,
|
|
|
|
[TIMER_WAITING] = UNIT_ACTIVE,
|
|
|
|
[TIMER_RUNNING] = UNIT_ACTIVE,
|
|
|
|
[TIMER_ELAPSED] = UNIT_ACTIVE,
|
2010-08-31 00:23:34 +02:00
|
|
|
[TIMER_FAILED] = UNIT_FAILED
|
2010-05-24 01:45:54 +02:00
|
|
|
};
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata);
|
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
static void timer_init(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2014-07-29 12:23:31 +02:00
|
|
|
t->next_elapse_monotonic_or_boottime = USEC_INFINITY;
|
|
|
|
t->next_elapse_realtime = USEC_INFINITY;
|
2014-03-24 16:22:34 +01:00
|
|
|
t->accuracy_usec = u->manager->default_timer_accuracy_usec;
|
2015-11-17 20:13:36 +01:00
|
|
|
t->remain_after_elapse = true;
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2013-01-17 02:27:06 +01:00
|
|
|
void timer_free_values(Timer *t) {
|
2010-05-24 01:45:54 +02:00
|
|
|
TimerValue *v;
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
|
|
|
while ((v = t->values)) {
|
2013-10-14 06:10:14 +02:00
|
|
|
LIST_REMOVE(value, t->values, v);
|
2015-08-17 10:45:30 +02:00
|
|
|
calendar_spec_free(v->calendar_spec);
|
2010-05-24 01:45:54 +02:00
|
|
|
free(v);
|
|
|
|
}
|
2013-01-17 02:27:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_done(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
|
|
|
timer_free_values(t);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
|
|
|
|
t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
|
2014-03-21 03:25:28 +01:00
|
|
|
|
|
|
|
free(t->stamp_path);
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int timer_verify(Timer *t) {
|
|
|
|
assert(t);
|
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(t)->load_state != UNIT_LOADED)
|
2010-05-24 01:45:54 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!t->values) {
|
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(t), "Timer unit lacks value setting. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-16 18:57:21 +02:00
|
|
|
static int timer_add_default_dependencies(Timer *t) {
|
|
|
|
int r;
|
2014-08-04 22:15:52 +02:00
|
|
|
TimerValue *v;
|
2010-07-16 18:57:21 +02:00
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
if (!UNIT(t)->default_dependencies)
|
|
|
|
return 0;
|
|
|
|
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(t), UNIT_BEFORE, SPECIAL_TIMERS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
|
2013-03-25 21:20:08 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-29 06:04:03 +02:00
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (MANAGER_IS_SYSTEM(UNIT(t)->manager)) {
|
2018-09-15 20:02:00 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(t), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
2010-07-16 18:57:21 +02:00
|
|
|
return r;
|
2014-08-04 22:15:52 +02:00
|
|
|
|
|
|
|
LIST_FOREACH(value, v, t->values) {
|
|
|
|
if (v->base == TIMER_CALENDAR) {
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(t), UNIT_AFTER, SPECIAL_TIME_SYNC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
|
2014-08-04 22:15:52 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-10-29 06:04:03 +02:00
|
|
|
}
|
2010-07-16 18:57:21 +02:00
|
|
|
|
2018-09-15 20:02:00 +02:00
|
|
|
return unit_add_two_dependencies_by_name(UNIT(t), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
|
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 timer_add_trigger_dependencies(Timer *t) {
|
|
|
|
Unit *x;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
|
|
|
if (!hashmap_isempty(UNIT(t)->dependencies[UNIT_TRIGGERS]))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = unit_load_related_unit(UNIT(t), ".service", &x);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return unit_add_two_dependencies(UNIT(t), UNIT_BEFORE, UNIT_TRIGGERS, x, true, UNIT_DEPENDENCY_IMPLICIT);
|
2010-07-16 18:57:21 +02:00
|
|
|
}
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
static int timer_setup_persistent(Timer *t) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
|
|
|
if (!t->persistent)
|
|
|
|
return 0;
|
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (MANAGER_IS_SYSTEM(UNIT(t)->manager)) {
|
2014-03-21 03:25:28 +01: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(t), "/var/lib/systemd/timers", UNIT_DEPENDENCY_FILE);
|
2014-03-21 03:25:28 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
t->stamp_path = strappend("/var/lib/systemd/timers/stamp-", UNIT(t)->id);
|
|
|
|
} else {
|
|
|
|
const char *e;
|
|
|
|
|
|
|
|
e = getenv("XDG_DATA_HOME");
|
|
|
|
if (e)
|
2016-10-23 17:43:27 +02:00
|
|
|
t->stamp_path = strjoin(e, "/systemd/timers/stamp-", UNIT(t)->id);
|
2014-03-21 03:25:28 +01:00
|
|
|
else {
|
|
|
|
|
|
|
|
_cleanup_free_ char *h = NULL;
|
|
|
|
|
|
|
|
r = get_home_dir(&h);
|
2014-11-28 18:23:20 +01:00
|
|
|
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(t), r, "Failed to determine home directory: %m");
|
2014-03-21 03:25:28 +01:00
|
|
|
|
2016-10-23 17:43:27 +02:00
|
|
|
t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id);
|
2014-03-21 03:25:28 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!t->stamp_path)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
static int timer_load(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
r = unit_load_fragment_and_dropin(u);
|
|
|
|
if (r < 0)
|
2010-05-24 01:45:54 +02:00
|
|
|
return r;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->load_state == UNIT_LOADED) {
|
2010-05-24 01:45:54 +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 = timer_add_trigger_dependencies(t);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-01-06 23:08:54 +01:00
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
r = timer_setup_persistent(t);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
r = timer_add_default_dependencies(t);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return timer_verify(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_dump(Unit *u, FILE *f, const char *prefix) {
|
2013-11-21 22:07:51 +01:00
|
|
|
char buf[FORMAT_TIMESPAN_MAX];
|
2010-05-24 01:45:54 +02:00
|
|
|
Timer *t = TIMER(u);
|
2013-04-23 20:53:16 +02:00
|
|
|
Unit *trigger;
|
2010-05-24 01:45:54 +02:00
|
|
|
TimerValue *v;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
trigger = UNIT_TRIGGER(u);
|
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
fprintf(f,
|
|
|
|
"%sTimer State: %s\n"
|
2012-02-03 04:03:21 +01:00
|
|
|
"%sResult: %s\n"
|
2013-11-21 22:07:51 +01:00
|
|
|
"%sUnit: %s\n"
|
2014-03-24 16:09:54 +01:00
|
|
|
"%sPersistent: %s\n"
|
|
|
|
"%sWakeSystem: %s\n"
|
2015-11-17 20:13:36 +01:00
|
|
|
"%sAccuracy: %s\n"
|
|
|
|
"%sRemainAfterElapse: %s\n",
|
2010-05-24 01:45:54 +02:00
|
|
|
prefix, timer_state_to_string(t->state),
|
2012-02-03 04:03:21 +01:00
|
|
|
prefix, timer_result_to_string(t->result),
|
2013-11-21 22:07:51 +01:00
|
|
|
prefix, trigger ? trigger->id : "n/a",
|
2014-03-24 16:09:54 +01:00
|
|
|
prefix, yes_no(t->persistent),
|
|
|
|
prefix, yes_no(t->wake_system),
|
2015-11-17 20:13:36 +01:00
|
|
|
prefix, format_timespan(buf, sizeof(buf), t->accuracy_usec, 1),
|
|
|
|
prefix, yes_no(t->remain_after_elapse));
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
LIST_FOREACH(value, v, t->values) {
|
|
|
|
|
|
|
|
if (v->base == TIMER_CALENDAR) {
|
|
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
|
2017-01-31 17:33:56 +01:00
|
|
|
(void) calendar_spec_to_string(v->calendar_spec, &p);
|
2012-11-23 21:37:58 +01:00
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"%s%s: %s\n",
|
|
|
|
prefix,
|
|
|
|
timer_base_to_string(v->base),
|
|
|
|
strna(p));
|
|
|
|
} else {
|
|
|
|
char timespan1[FORMAT_TIMESPAN_MAX];
|
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"%s%s: %s\n",
|
|
|
|
prefix,
|
|
|
|
timer_base_to_string(v->base),
|
2014-09-29 14:31:14 +02:00
|
|
|
format_timespan(timespan1, sizeof(timespan1), v->value, 0));
|
2012-11-23 21:37:58 +01:00
|
|
|
}
|
|
|
|
}
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_set_state(Timer *t, TimerState state) {
|
|
|
|
TimerState old_state;
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(t);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
old_state = t->state;
|
|
|
|
t->state = state;
|
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
if (state != TIMER_WAITING) {
|
2013-11-19 21:12:59 +01:00
|
|
|
t->monotonic_event_source = sd_event_source_unref(t->monotonic_event_source);
|
|
|
|
t->realtime_event_source = sd_event_source_unref(t->realtime_event_source);
|
2016-10-17 08:05:30 +02:00
|
|
|
t->next_elapse_monotonic_or_boottime = USEC_INFINITY;
|
|
|
|
t->next_elapse_realtime = USEC_INFINITY;
|
2012-11-23 21:37:58 +01:00
|
|
|
}
|
2010-05-24 01:45:54 +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(t), "Changed %s -> %s", timer_state_to_string(old_state), timer_state_to_string(state));
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2018-06-01 19:06:19 +02:00
|
|
|
unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], 0);
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
2018-10-28 13:26:13 +01:00
|
|
|
static void timer_enter_waiting(Timer *t, bool initial, bool time_change);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2015-04-24 15:27:19 +02:00
|
|
|
static int timer_coldplug(Unit *u) {
|
2010-05-24 01:45:54 +02:00
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
assert(t->state == TIMER_DEAD);
|
|
|
|
|
2015-11-17 20:13:36 +01:00
|
|
|
if (t->deserialized_state == t->state)
|
|
|
|
return 0;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2015-11-17 20:13:36 +01:00
|
|
|
if (t->deserialized_state == TIMER_WAITING)
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, false, false);
|
2015-11-17 20:13:36 +01:00
|
|
|
else
|
|
|
|
timer_set_state(t, t->deserialized_state);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
static void timer_enter_dead(Timer *t, TimerResult f) {
|
2010-05-24 01:45:54 +02:00
|
|
|
assert(t);
|
|
|
|
|
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 (t->result == TIMER_SUCCESS)
|
2012-02-03 04:03:21 +01:00
|
|
|
t->result = f;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2018-11-16 10:09:45 +01:00
|
|
|
unit_log_result(UNIT(t), t->result == TIMER_SUCCESS, timer_result_to_string(t->result));
|
2012-02-03 04:03:21 +01:00
|
|
|
timer_set_state(t, t->result != TIMER_SUCCESS ? TIMER_FAILED : TIMER_DEAD);
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
2015-11-17 20:13:36 +01:00
|
|
|
static void timer_enter_elapsed(Timer *t, bool leave_around) {
|
|
|
|
assert(t);
|
|
|
|
|
|
|
|
/* If a unit is marked with RemainAfterElapse=yes we leave it
|
|
|
|
* around even after it elapsed once, so that starting it
|
|
|
|
* later again does not necessarily mean immediate
|
|
|
|
* retriggering. We unconditionally leave units with
|
|
|
|
* TIMER_UNIT_ACTIVE or TIMER_UNIT_INACTIVE triggers around,
|
|
|
|
* since they might be restarted automatically at any time
|
|
|
|
* later on. */
|
|
|
|
|
|
|
|
if (t->remain_after_elapse || leave_around)
|
|
|
|
timer_set_state(t, TIMER_ELAPSED);
|
|
|
|
else
|
|
|
|
timer_enter_dead(t, TIMER_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2015-11-18 13:37:30 +01:00
|
|
|
static void add_random(Timer *t, usec_t *v) {
|
|
|
|
char s[FORMAT_TIMESPAN_MAX];
|
|
|
|
usec_t add;
|
|
|
|
|
|
|
|
assert(t);
|
2016-02-16 13:18:36 +01:00
|
|
|
assert(v);
|
2015-11-18 13:37:30 +01:00
|
|
|
|
|
|
|
if (t->random_usec == 0)
|
|
|
|
return;
|
|
|
|
if (*v == USEC_INFINITY)
|
|
|
|
return;
|
|
|
|
|
|
|
|
add = random_u64() % t->random_usec;
|
|
|
|
|
|
|
|
if (*v + add < *v) /* overflow */
|
|
|
|
*v = (usec_t) -2; /* Highest possible value, that is not USEC_INFINITY */
|
|
|
|
else
|
|
|
|
*v += add;
|
|
|
|
|
2017-02-05 09:37:46 +01:00
|
|
|
log_unit_debug(UNIT(t), "Adding %s random time.", format_timespan(s, sizeof(s), add, 0));
|
2015-11-18 13:37:30 +01:00
|
|
|
}
|
|
|
|
|
2018-10-28 13:26:13 +01:00
|
|
|
static void timer_enter_waiting(Timer *t, bool initial, bool time_change) {
|
2012-11-23 21:37:58 +01:00
|
|
|
bool found_monotonic = false, found_realtime = false;
|
2015-11-17 20:13:36 +01:00
|
|
|
bool leave_around = false;
|
2017-06-22 21:04:20 +02:00
|
|
|
triple_timestamp ts;
|
2014-03-24 16:09:54 +01:00
|
|
|
TimerValue *v;
|
2016-02-10 23:39:31 +01:00
|
|
|
Unit *trigger;
|
2010-05-24 01:45:54 +02:00
|
|
|
int r;
|
|
|
|
|
2016-02-10 23:39:31 +01:00
|
|
|
assert(t);
|
|
|
|
|
|
|
|
trigger = UNIT_TRIGGER(UNIT(t));
|
|
|
|
if (!trigger) {
|
|
|
|
log_unit_error(UNIT(t), "Unit to trigger vanished.");
|
|
|
|
timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-22 21:04:20 +02:00
|
|
|
triple_timestamp_get(&ts);
|
2014-03-24 16:09:54 +01:00
|
|
|
t->next_elapse_monotonic_or_boottime = t->next_elapse_realtime = 0;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
LIST_FOREACH(value, v, t->values) {
|
|
|
|
if (v->disabled)
|
|
|
|
continue;
|
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
if (v->base == TIMER_CALENDAR) {
|
2014-03-21 03:25:28 +01:00
|
|
|
usec_t b;
|
|
|
|
|
|
|
|
/* If we know the last time this was
|
|
|
|
* triggered, schedule the job based relative
|
core: let OnCalendar= timer units expire during suspend (#8231)
On timejumps, including suspend, timer_time_change() calls for a
re-calculation of the next elapse. Sadly I'm not quite sure what the
intended effect of this was! Because it was not managing to fire
OnCalendar= timers which fired during the suspend... unless the timer had
already fired once before.
Reported, entirely correctly as far as I can see, on stackexchange:
https://unix.stackexchange.com/questions/351829/systemd-timer-that-expired-while-suspended
/* If we know the last time this was
* triggered, schedule the job based relative
- * to that. If we don't just start from
- * now. */
+ * to that. If we don't, just start from
+ * the activation time. */
The same code is called for both the initial calculation and this
re-calculation. If we're _not_ already active, then this is before the
activation time has been recorded in the unit, so just use the current
time as before. The new code is mechanically adapted from the same
logic for `OnActiveSec=` (case TIMER_ACTIVE in the code which follows).
Tested with `date --set`.
Motivations:
* Rotate monitoring data from Atop into files which are named per-day.
Fedora currently implements this with a cron job that runs at midnight,
but that didn't handle suspend correctly either.
* unbound-anchor.timer on Fedora, is used to update DNSSEC "root trust
anchor" daily, before the TTL expires. It uses OnCalendar=daily
AccuracySec=24h. Which is a bit suspect because the TTL is 2 days, but I
think it has the right general idea.
None of the other timer settings are correct, because they would not
account for time spent in suspend. Unless you set WakeSystem
(this feature is currently undocumented).
* So in general, we can expect to see people using OnCalendar= for the same
cases as cron.daily and cron.monthly. Which use anacron to keep track of
jobs which should be run even if the system was down at the time.
Timers which are configured to run more frequently than that, are
unlikely to mind if they get run slightly more often that the writer
realized, relative to the amount of time the system was really running.
* From the user report above: "I only want to use remind to show a desktop
notification, it seems excessive to wake up the computer for that. Also,
I would like to get the reminder first thing in the morning, so the
OnActiveSec doesn't help with that."
2018-02-28 16:34:16 +01:00
|
|
|
* to that. If we don't, just start from
|
|
|
|
* the activation time. */
|
|
|
|
|
|
|
|
if (t->last_trigger.realtime > 0)
|
|
|
|
b = t->last_trigger.realtime;
|
|
|
|
else {
|
|
|
|
if (state_translation_table[t->state] == UNIT_ACTIVE)
|
|
|
|
b = UNIT(t)->inactive_exit_timestamp.realtime;
|
|
|
|
else
|
|
|
|
b = ts.realtime;
|
|
|
|
}
|
2014-03-21 03:25:28 +01:00
|
|
|
|
|
|
|
r = calendar_spec_next_usec(v->calendar_spec, b, &v->next_elapse);
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!found_realtime)
|
|
|
|
t->next_elapse_realtime = v->next_elapse;
|
2010-10-27 00:01:12 +02:00
|
|
|
else
|
2012-11-23 21:37:58 +01:00
|
|
|
t->next_elapse_realtime = MIN(t->next_elapse_realtime, v->next_elapse);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
found_realtime = true;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2018-02-28 16:07:30 +01:00
|
|
|
} else {
|
|
|
|
usec_t base;
|
2017-06-22 21:04:20 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
switch (v->base) {
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
case TIMER_ACTIVE:
|
|
|
|
if (state_translation_table[t->state] == UNIT_ACTIVE)
|
|
|
|
base = UNIT(t)->inactive_exit_timestamp.monotonic;
|
|
|
|
else
|
2017-06-22 21:04:20 +02:00
|
|
|
base = ts.monotonic;
|
2012-11-23 21:37:58 +01:00
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
case TIMER_BOOT:
|
2015-11-07 15:09:31 +01:00
|
|
|
if (detect_container() <= 0) {
|
|
|
|
/* CLOCK_MONOTONIC equals the uptime on Linux */
|
|
|
|
base = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* In a container we don't want to include the time the host
|
|
|
|
* was already up when the container started, so count from
|
2017-01-27 06:50:10 +01:00
|
|
|
* our own startup. */
|
2017-11-19 19:06:10 +01:00
|
|
|
_fallthrough_;
|
2012-11-23 21:37:58 +01:00
|
|
|
case TIMER_STARTUP:
|
2017-11-20 21:01:13 +01:00
|
|
|
base = UNIT(t)->manager->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
|
2012-11-23 21:37:58 +01:00
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
case TIMER_UNIT_ACTIVE:
|
2015-11-17 20:13:36 +01:00
|
|
|
leave_around = true;
|
2016-02-10 23:39:31 +01:00
|
|
|
base = trigger->inactive_exit_timestamp.monotonic;
|
2013-04-23 22:42:31 +02:00
|
|
|
|
|
|
|
if (base <= 0)
|
2014-03-21 03:25:28 +01:00
|
|
|
base = t->last_trigger.monotonic;
|
2013-04-23 22:42:31 +02:00
|
|
|
|
|
|
|
if (base <= 0)
|
2012-11-23 21:37:58 +01:00
|
|
|
continue;
|
2018-01-16 19:22:46 +01:00
|
|
|
base = MAX(base, t->last_trigger.monotonic);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
case TIMER_UNIT_INACTIVE:
|
2015-11-17 20:13:36 +01:00
|
|
|
leave_around = true;
|
2016-02-10 23:39:31 +01:00
|
|
|
base = trigger->inactive_enter_timestamp.monotonic;
|
2013-04-23 22:42:31 +02:00
|
|
|
|
|
|
|
if (base <= 0)
|
2014-03-21 03:25:28 +01:00
|
|
|
base = t->last_trigger.monotonic;
|
2013-04-23 22:42:31 +02:00
|
|
|
|
|
|
|
if (base <= 0)
|
2012-11-23 21:37:58 +01:00
|
|
|
continue;
|
2018-01-16 19:22:46 +01:00
|
|
|
base = MAX(base, t->last_trigger.monotonic);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
default:
|
|
|
|
assert_not_reached("Unknown timer base");
|
|
|
|
}
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2017-06-22 21:04:20 +02:00
|
|
|
v->next_elapse = usec_add(usec_shift_clock(base, CLOCK_MONOTONIC, TIMER_MONOTONIC_CLOCK(t)), v->value);
|
2012-11-23 21:37:58 +01:00
|
|
|
|
2018-10-28 13:26:13 +01:00
|
|
|
if (!initial && !time_change &&
|
2017-06-22 21:04:20 +02:00
|
|
|
v->next_elapse < triple_timestamp_by_clock(&ts, TIMER_MONOTONIC_CLOCK(t)) &&
|
|
|
|
IN_SET(v->base, TIMER_ACTIVE, TIMER_BOOT, TIMER_STARTUP)) {
|
2013-04-23 22:42:31 +02:00
|
|
|
/* This is a one time trigger, disable it now */
|
2012-11-23 21:37:58 +01:00
|
|
|
v->disabled = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found_monotonic)
|
2014-03-24 16:09:54 +01:00
|
|
|
t->next_elapse_monotonic_or_boottime = v->next_elapse;
|
2012-11-23 21:37:58 +01:00
|
|
|
else
|
2014-03-24 16:09:54 +01:00
|
|
|
t->next_elapse_monotonic_or_boottime = MIN(t->next_elapse_monotonic_or_boottime, v->next_elapse);
|
2012-11-23 21:37:58 +01:00
|
|
|
|
|
|
|
found_monotonic = true;
|
|
|
|
}
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
if (!found_monotonic && !found_realtime) {
|
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(t), "Timer is elapsed.");
|
2015-11-17 20:13:36 +01:00
|
|
|
timer_enter_elapsed(t, leave_around);
|
2010-05-24 01:45:54 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
if (found_monotonic) {
|
|
|
|
char buf[FORMAT_TIMESPAN_MAX];
|
2015-11-17 20:13:36 +01:00
|
|
|
usec_t left;
|
2014-03-24 16:09:54 +01:00
|
|
|
|
2015-11-18 13:37:30 +01:00
|
|
|
add_random(t, &t->next_elapse_monotonic_or_boottime);
|
|
|
|
|
2017-06-22 21:04:20 +02:00
|
|
|
left = usec_sub_unsigned(t->next_elapse_monotonic_or_boottime, triple_timestamp_by_clock(&ts, TIMER_MONOTONIC_CLOCK(t)));
|
2015-11-17 20:13:36 +01:00
|
|
|
log_unit_debug(UNIT(t), "Monotonic timer elapses in %s.", format_timespan(buf, sizeof(buf), left, 0));
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (t->monotonic_event_source) {
|
2014-03-24 16:09:54 +01:00
|
|
|
r = sd_event_source_set_time(t->monotonic_event_source, t->next_elapse_monotonic_or_boottime);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_ONESHOT);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
} else {
|
|
|
|
|
2014-03-24 02:49:09 +01:00
|
|
|
r = sd_event_add_time(
|
|
|
|
UNIT(t)->manager->event,
|
|
|
|
&t->monotonic_event_source,
|
2014-03-24 16:09:54 +01:00
|
|
|
t->wake_system ? CLOCK_BOOTTIME_ALARM : CLOCK_MONOTONIC,
|
|
|
|
t->next_elapse_monotonic_or_boottime, t->accuracy_usec,
|
2014-03-24 02:49:09 +01:00
|
|
|
timer_dispatch, t);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2015-05-13 18:30:14 +02:00
|
|
|
(void) sd_event_source_set_description(t->monotonic_event_source, "timer-monotonic");
|
|
|
|
}
|
2015-04-29 16:05:32 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
} else if (t->monotonic_event_source) {
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_OFF);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-11-23 21:37:58 +01:00
|
|
|
|
|
|
|
if (found_realtime) {
|
|
|
|
char buf[FORMAT_TIMESTAMP_MAX];
|
2015-11-18 13:37:30 +01:00
|
|
|
|
|
|
|
add_random(t, &t->next_elapse_realtime);
|
|
|
|
|
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(t), "Realtime timer elapses at %s.", format_timestamp(buf, sizeof(buf), t->next_elapse_realtime));
|
2012-11-23 21:37:58 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (t->realtime_event_source) {
|
|
|
|
r = sd_event_source_set_time(t->realtime_event_source, t->next_elapse_realtime);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_ONESHOT);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
} else {
|
2014-03-24 02:49:09 +01:00
|
|
|
r = sd_event_add_time(
|
|
|
|
UNIT(t)->manager->event,
|
|
|
|
&t->realtime_event_source,
|
2014-03-24 16:09:54 +01:00
|
|
|
t->wake_system ? CLOCK_REALTIME_ALARM : CLOCK_REALTIME,
|
2014-03-24 02:49:09 +01:00
|
|
|
t->next_elapse_realtime, t->accuracy_usec,
|
|
|
|
timer_dispatch, t);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2015-05-13 18:30:14 +02:00
|
|
|
(void) sd_event_source_set_description(t->realtime_event_source, "timer-realtime");
|
|
|
|
}
|
2015-04-29 16:05:32 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
} else if (t->realtime_event_source) {
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_OFF);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
timer_set_state(t, TIMER_WAITING);
|
|
|
|
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(t), r, "Failed to enter waiting state: %m");
|
2012-02-03 04:03:21 +01:00
|
|
|
timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_enter_running(Timer *t) {
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
|
2016-02-10 23:39:31 +01:00
|
|
|
Unit *trigger;
|
2010-05-24 01:45:54 +02:00
|
|
|
int r;
|
2010-07-08 02:43:18 +02:00
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
assert(t);
|
|
|
|
|
2010-07-13 00:27:27 +02:00
|
|
|
/* Don't start job if we are supposed to go down */
|
2013-04-26 02:57:41 +02:00
|
|
|
if (unit_stop_pending(UNIT(t)))
|
2010-07-13 00:27:27 +02:00
|
|
|
return;
|
|
|
|
|
2016-02-10 23:39:31 +01:00
|
|
|
trigger = UNIT_TRIGGER(UNIT(t));
|
|
|
|
if (!trigger) {
|
|
|
|
log_unit_error(UNIT(t), "Unit to trigger vanished.");
|
|
|
|
timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = manager_add_job(UNIT(t)->manager, JOB_START, trigger, JOB_REPLACE, &error, NULL);
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
2010-05-24 01:45:54 +02:00
|
|
|
goto fail;
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
dual_timestamp_get(&t->last_trigger);
|
|
|
|
|
2014-04-02 20:18:44 +02:00
|
|
|
if (t->stamp_path)
|
2015-11-11 22:54:56 +01:00
|
|
|
touch_file(t->stamp_path, true, t->last_trigger.realtime, UID_INVALID, GID_INVALID, MODE_INVALID);
|
2013-04-23 22:42:31 +02:00
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
timer_set_state(t, TIMER_RUNNING);
|
|
|
|
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(UNIT(t), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
|
2012-02-03 04:03:21 +01:00
|
|
|
timer_enter_dead(t, TIMER_FAILURE_RESOURCES);
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int timer_start(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
2014-11-06 09:47:02 +01:00
|
|
|
TimerValue *v;
|
2016-02-10 23:39:31 +01:00
|
|
|
Unit *trigger;
|
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-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
assert(t);
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(t->state, TIMER_DEAD, TIMER_FAILED));
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2016-02-10 23:39:31 +01:00
|
|
|
trigger = UNIT_TRIGGER(u);
|
|
|
|
if (!trigger || trigger->load_state != UNIT_LOADED) {
|
|
|
|
log_unit_error(u, "Refusing to start, unit to trigger not loaded.");
|
2010-05-24 05:25:33 +02:00
|
|
|
return -ENOENT;
|
2016-02-10 23:39:31 +01:00
|
|
|
}
|
2010-05-24 01:45:54 +02:00
|
|
|
|
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) {
|
|
|
|
timer_enter_dead(t, TIMER_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;
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
t->last_trigger = DUAL_TIMESTAMP_NULL;
|
|
|
|
|
2014-11-06 09:47:02 +01:00
|
|
|
/* Reenable all timers that depend on unit activation time */
|
|
|
|
LIST_FOREACH(value, v, t->values)
|
|
|
|
if (v->base == TIMER_ACTIVE)
|
|
|
|
v->disabled = false;
|
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
if (t->stamp_path) {
|
|
|
|
struct stat st;
|
|
|
|
|
2017-09-14 18:26:10 +02:00
|
|
|
if (stat(t->stamp_path, &st) >= 0) {
|
|
|
|
usec_t ft;
|
|
|
|
|
|
|
|
/* Load the file timestamp, but only if it is actually in the past. If it is in the future,
|
|
|
|
* something is wrong with the system clock. */
|
|
|
|
|
|
|
|
ft = timespec_load(&st.st_mtim);
|
|
|
|
if (ft < now(CLOCK_REALTIME))
|
|
|
|
t->last_trigger.realtime = ft;
|
|
|
|
else {
|
|
|
|
char z[FORMAT_TIMESTAMP_MAX];
|
|
|
|
|
|
|
|
log_unit_warning(u, "Not using persistent file timestamp %s as it is in the future.",
|
|
|
|
format_timestamp(z, sizeof(z), ft));
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (errno == ENOENT)
|
2014-04-02 20:18:44 +02:00
|
|
|
/* The timer has never run before,
|
|
|
|
* make sure a stamp file exists.
|
|
|
|
*/
|
2016-08-30 23:18:46 +02:00
|
|
|
(void) touch_file(t->stamp_path, true, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
|
2014-03-21 03:25:28 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
t->result = TIMER_SUCCESS;
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, true, false);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int timer_stop(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(t);
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(t->state, TIMER_WAITING, TIMER_RUNNING, TIMER_ELAPSED));
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
timer_enter_dead(t, TIMER_SUCCESS);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int timer_serialize(Unit *u, FILE *f, FDSet *fds) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_item(f, "state", timer_state_to_string(t->state));
|
|
|
|
(void) serialize_item(f, "result", timer_result_to_string(t->result));
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2014-03-21 03:25:28 +01:00
|
|
|
if (t->last_trigger.realtime > 0)
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_usec(f, "last-trigger-realtime", t->last_trigger.realtime);
|
2014-03-21 03:25:28 +01:00
|
|
|
|
|
|
|
if (t->last_trigger.monotonic > 0)
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_usec(f, "last-trigger-monotonic", t->last_trigger.monotonic);
|
2014-03-21 03:25:28 +01:00
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int timer_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(key);
|
|
|
|
assert(value);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
if (streq(key, "state")) {
|
|
|
|
TimerState state;
|
|
|
|
|
2012-11-23 21:37:58 +01:00
|
|
|
state = timer_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-24 01:45:54 +02:00
|
|
|
else
|
|
|
|
t->deserialized_state = state;
|
2018-10-17 20:40:09 +02:00
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
} else if (streq(key, "result")) {
|
|
|
|
TimerResult f;
|
|
|
|
|
|
|
|
f = timer_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:03:21 +01:00
|
|
|
else if (f != TIMER_SUCCESS)
|
|
|
|
t->result = f;
|
2014-03-21 03:25:28 +01:00
|
|
|
|
2018-10-17 20:40:09 +02:00
|
|
|
} else if (streq(key, "last-trigger-realtime"))
|
|
|
|
(void) deserialize_usec(value, &t->last_trigger.realtime);
|
|
|
|
else if (streq(key, "last-trigger-monotonic"))
|
|
|
|
(void) deserialize_usec(value, &t->last_trigger.monotonic);
|
|
|
|
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-24 01:45:54 +02:00
|
|
|
|
|
|
|
return 0;
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static UnitActiveState timer_active_state(Unit *u) {
|
2010-05-24 01:45:54 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return state_translation_table[TIMER(u)->state];
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static const char *timer_sub_state_to_string(Unit *u) {
|
2010-05-24 01:45:54 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return timer_state_to_string(TIMER(u)->state);
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int timer_dispatch(sd_event_source *s, uint64_t usec, void *userdata) {
|
|
|
|
Timer *t = TIMER(userdata);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
|
|
|
assert(t);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
if (t->state != TIMER_WAITING)
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-01-23 01:52:57 +01: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
|
|
|
log_unit_debug(UNIT(t), "Timer elapsed.");
|
2010-05-24 01:45:54 +02:00
|
|
|
timer_enter_running(t);
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
static void timer_trigger_notify(Unit *u, Unit *other) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
TimerValue *v;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
assert(u);
|
|
|
|
assert(other);
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
if (other->load_state != UNIT_LOADED)
|
|
|
|
return;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
/* Reenable all timers that depend on unit state */
|
|
|
|
LIST_FOREACH(value, v, t->values)
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(v->base, TIMER_UNIT_ACTIVE, TIMER_UNIT_INACTIVE))
|
2013-04-23 20:53:16 +02:00
|
|
|
v->disabled = false;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
switch (t->state) {
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
case TIMER_WAITING:
|
|
|
|
case TIMER_ELAPSED:
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
/* Recalculate sleep time */
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, false, false);
|
2013-04-23 20:53:16 +02:00
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
case TIMER_RUNNING:
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
|
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(t), "Got notified about unit deactivation.");
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, false, false);
|
2013-04-23 20:53:16 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
case TIMER_DEAD:
|
|
|
|
case TIMER_FAILED:
|
|
|
|
break;
|
2010-05-24 01:45:54 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
default:
|
|
|
|
assert_not_reached("Unknown timer state");
|
2010-05-24 01:45:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
static void timer_reset_failed(Unit *u) {
|
2010-07-18 04:58:01 +02:00
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(t);
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
if (t->state == TIMER_FAILED)
|
2010-07-18 04:58:01 +02:00
|
|
|
timer_set_state(t, TIMER_DEAD);
|
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
t->result = TIMER_SUCCESS;
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
static void timer_time_change(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
2018-02-28 17:03:43 +01:00
|
|
|
usec_t ts;
|
2012-11-25 00:32:40 +01:00
|
|
|
|
|
|
|
assert(u);
|
|
|
|
|
|
|
|
if (t->state != TIMER_WAITING)
|
|
|
|
return;
|
|
|
|
|
2018-02-28 17:03:43 +01:00
|
|
|
/* If we appear to have triggered in the future, the system clock must
|
|
|
|
* have been set backwards. So let's rewind our own clock and allow
|
|
|
|
* the future trigger(s) to happen again :). Exactly the same as when
|
|
|
|
* you start a timer unit with Persistent=yes. */
|
|
|
|
ts = now(CLOCK_REALTIME);
|
|
|
|
if (t->last_trigger.realtime > ts)
|
|
|
|
t->last_trigger.realtime = ts;
|
|
|
|
|
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, "Time change, recalculating next elapse.");
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, false, true);
|
2012-11-25 00:32:40 +01:00
|
|
|
}
|
|
|
|
|
2018-05-28 21:33:10 +02:00
|
|
|
static void timer_timezone_change(Unit *u) {
|
|
|
|
Timer *t = TIMER(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
|
|
|
|
if (t->state != TIMER_WAITING)
|
|
|
|
return;
|
|
|
|
|
|
|
|
log_unit_debug(u, "Timezone change, recalculating next elapse.");
|
2018-10-28 13:26:13 +01:00
|
|
|
timer_enter_waiting(t, false, false);
|
2018-05-28 21:33:10 +02:00
|
|
|
}
|
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
static const char* const timer_base_table[_TIMER_BASE_MAX] = {
|
2010-07-04 21:12:10 +02:00
|
|
|
[TIMER_ACTIVE] = "OnActiveSec",
|
|
|
|
[TIMER_BOOT] = "OnBootSec",
|
|
|
|
[TIMER_STARTUP] = "OnStartupSec",
|
|
|
|
[TIMER_UNIT_ACTIVE] = "OnUnitActiveSec",
|
2012-11-23 21:37:58 +01:00
|
|
|
[TIMER_UNIT_INACTIVE] = "OnUnitInactiveSec",
|
|
|
|
[TIMER_CALENDAR] = "OnCalendar"
|
2010-05-24 01:45:54 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(timer_base, TimerBase);
|
|
|
|
|
2012-02-03 04:03:21 +01:00
|
|
|
static const char* const timer_result_table[_TIMER_RESULT_MAX] = {
|
|
|
|
[TIMER_SUCCESS] = "success",
|
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
|
|
|
[TIMER_FAILURE_RESOURCES] = "resources",
|
|
|
|
[TIMER_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
|
2012-02-03 04:03:21 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(timer_result, TimerResult);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
const UnitVTable timer_vtable = {
|
2012-01-15 10:53:49 +01:00
|
|
|
.object_size = sizeof(Timer),
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
.sections =
|
|
|
|
"Unit\0"
|
|
|
|
"Timer\0"
|
|
|
|
"Install\0",
|
2014-12-08 16:03:53 +01:00
|
|
|
.private_section = "Timer",
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-05-24 01:45:54 +02:00
|
|
|
.init = timer_init,
|
2010-01-26 04:18:44 +01:00
|
|
|
.done = timer_done,
|
2010-05-24 01:45:54 +02:00
|
|
|
.load = timer_load,
|
|
|
|
|
|
|
|
.coldplug = timer_coldplug,
|
|
|
|
|
|
|
|
.dump = timer_dump,
|
|
|
|
|
|
|
|
.start = timer_start,
|
|
|
|
.stop = timer_stop,
|
|
|
|
|
|
|
|
.serialize = timer_serialize,
|
|
|
|
.deserialize_item = timer_deserialize_item,
|
|
|
|
|
|
|
|
.active_state = timer_active_state,
|
|
|
|
.sub_state_to_string = timer_sub_state_to_string,
|
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
.trigger_notify = timer_trigger_notify,
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
.reset_failed = timer_reset_failed,
|
2012-11-25 00:32:40 +01:00
|
|
|
.time_change = timer_time_change,
|
2018-05-28 21:33:10 +02:00
|
|
|
.timezone_change = timer_timezone_change,
|
2010-07-18 04:58:01 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
.bus_vtable = bus_timer_vtable,
|
2014-12-08 16:03:53 +01:00
|
|
|
.bus_set_property = bus_timer_set_property,
|
|
|
|
|
|
|
|
.can_transient = true,
|
2010-01-23 01:52:57 +01:00
|
|
|
};
|