2010-05-24 05:25:33 +02:00
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
2012-04-12 00:20:58 +02:00
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-05-24 05:25:33 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2012-04-12 00:20:58 +02:00
|
|
|
Lesser General Public License for more details.
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-05-24 05:25:33 +02:00
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include <errno.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <sys/epoll.h>
|
|
|
|
#include <sys/inotify.h>
|
2010-05-24 05:25:33 +02:00
|
|
|
#include <unistd.h>
|
|
|
|
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "bus-error.h"
|
|
|
|
#include "bus-util.h"
|
2010-05-24 05:25:33 +02:00
|
|
|
#include "dbus-path.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "fd-util.h"
|
2015-10-27 14:58:05 +01:00
|
|
|
#include "fs-util.h"
|
2015-10-27 01:48:17 +01:00
|
|
|
#include "glob-util.h"
|
2013-03-01 23:44:25 +01:00
|
|
|
#include "macro.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "mkdir.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "path.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "special.h"
|
2015-10-26 22:01:44 +01:00
|
|
|
#include "stat-util.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"
|
|
|
|
#include "unit-name.h"
|
|
|
|
#include "unit.h"
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
|
|
|
|
[PATH_DEAD] = UNIT_INACTIVE,
|
|
|
|
[PATH_WAITING] = UNIT_ACTIVE,
|
|
|
|
[PATH_RUNNING] = UNIT_ACTIVE,
|
2010-08-31 00:23:34 +02:00
|
|
|
[PATH_FAILED] = UNIT_FAILED
|
2010-05-24 05:25:33 +02:00
|
|
|
};
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
|
|
|
|
int path_spec_watch(PathSpec *s, sd_event_io_handler_t handler) {
|
2012-01-06 23:08:54 +01:00
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
static const int flags_table[_PATH_TYPE_MAX] = {
|
|
|
|
[PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
|
|
|
|
[PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
|
|
|
|
[PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
|
2011-12-03 10:22:26 +01:00
|
|
|
[PATH_MODIFIED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO|IN_MODIFY,
|
2011-12-03 01:38:30 +01:00
|
|
|
[PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
|
|
|
|
};
|
|
|
|
|
|
|
|
bool exists = false;
|
2013-03-03 07:32:34 +01:00
|
|
|
char *slash, *oldslash = NULL;
|
2011-12-03 01:38:30 +01:00
|
|
|
int r;
|
2011-04-10 01:30:14 +02:00
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
assert(s);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(s->unit);
|
|
|
|
assert(handler);
|
2011-04-10 01:30:14 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
path_spec_unwatch(s);
|
2011-12-03 01:38:30 +01:00
|
|
|
|
2013-03-01 23:44:25 +01:00
|
|
|
s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
|
|
|
|
if (s->inotify_fd < 0) {
|
2011-12-03 01:38:30 +01:00
|
|
|
r = -errno;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(s->unit->manager->event, &s->event_source, s->inotify_fd, EPOLLIN, handler, s);
|
2013-03-01 23:44:25 +01:00
|
|
|
if (r < 0)
|
2011-12-03 01:38:30 +01:00
|
|
|
goto fail;
|
|
|
|
|
2015-04-29 16:05:32 +02:00
|
|
|
(void) sd_event_source_set_description(s->event_source, "path");
|
|
|
|
|
2013-03-03 07:32:34 +01:00
|
|
|
/* This assumes the path was passed through path_kill_slashes()! */
|
2011-12-03 01:38:30 +01:00
|
|
|
|
2013-03-06 19:28:55 +01:00
|
|
|
for (slash = strchr(s->path, '/'); ; slash = strchr(slash+1, '/')) {
|
|
|
|
char *cut = NULL;
|
2011-12-03 01:38:30 +01:00
|
|
|
int flags;
|
2013-03-03 07:32:34 +01:00
|
|
|
char tmp;
|
|
|
|
|
|
|
|
if (slash) {
|
2013-03-06 19:28:55 +01:00
|
|
|
cut = slash + (slash == s->path);
|
|
|
|
tmp = *cut;
|
|
|
|
*cut = '\0';
|
|
|
|
|
2013-03-03 07:32:34 +01:00
|
|
|
flags = IN_MOVE_SELF | IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
|
2013-03-06 19:28:55 +01:00
|
|
|
} else
|
2013-03-03 07:32:34 +01:00
|
|
|
flags = flags_table[s->type];
|
2011-12-03 01:38:30 +01:00
|
|
|
|
2013-03-06 19:28:55 +01:00
|
|
|
r = inotify_add_watch(s->inotify_fd, s->path, flags);
|
2013-03-03 07:32:34 +01:00
|
|
|
if (r < 0) {
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(errno, EACCES, ENOENT)) {
|
2013-03-06 19:28:55 +01:00
|
|
|
if (cut)
|
|
|
|
*cut = tmp;
|
2013-03-03 07:32:34 +01:00
|
|
|
break;
|
2013-03-06 19:28:55 +01:00
|
|
|
}
|
2011-12-03 01:38:30 +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
|
|
|
r = log_warning_errno(errno, "Failed to add watch on %s: %s", s->path, errno == ENOSPC ? "too many watches" : strerror(-r));
|
2013-03-06 19:28:55 +01:00
|
|
|
if (cut)
|
|
|
|
*cut = tmp;
|
2013-03-03 07:49:11 +01:00
|
|
|
goto fail;
|
2013-03-03 07:32:34 +01:00
|
|
|
} else {
|
|
|
|
exists = true;
|
|
|
|
|
2016-04-09 03:08:23 +02:00
|
|
|
/* Path exists, we don't need to watch parent too closely. */
|
2013-03-03 07:32:34 +01:00
|
|
|
if (oldslash) {
|
2013-03-06 19:28:55 +01:00
|
|
|
char *cut2 = oldslash + (oldslash == s->path);
|
|
|
|
char tmp2 = *cut2;
|
|
|
|
*cut2 = '\0';
|
2013-03-03 07:32:34 +01:00
|
|
|
|
2016-04-09 03:08:23 +02:00
|
|
|
(void) inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
|
|
|
|
/* Error is ignored, the worst can happen is we get spurious events. */
|
2013-03-03 07:32:34 +01:00
|
|
|
|
2013-03-06 19:28:55 +01:00
|
|
|
*cut2 = tmp2;
|
2013-03-03 07:32:34 +01:00
|
|
|
}
|
2013-03-03 07:49:11 +01:00
|
|
|
}
|
2013-03-03 07:32:34 +01:00
|
|
|
|
2013-03-06 19:28:55 +01:00
|
|
|
if (cut)
|
|
|
|
*cut = tmp;
|
|
|
|
|
|
|
|
if (slash)
|
2013-03-03 07:32:34 +01:00
|
|
|
oldslash = slash;
|
2013-03-06 19:28:55 +01:00
|
|
|
else {
|
2013-03-03 07:32:34 +01:00
|
|
|
/* whole path has been iterated over */
|
|
|
|
s->primary_wd = r;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-03 07:49:11 +01:00
|
|
|
if (!exists) {
|
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 = log_error_errno(errno, "Failed to add watch on any of the components of %s: %m", s->path);
|
|
|
|
/* either EACCESS or ENOENT */
|
2013-03-03 07:49:11 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2013-11-19 21:12:59 +01:00
|
|
|
path_spec_unwatch(s);
|
2011-12-03 01:38:30 +01:00
|
|
|
return r;
|
2011-04-10 01:30:14 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
void path_spec_unwatch(PathSpec *s) {
|
|
|
|
assert(s);
|
2010-11-15 21:30:52 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
s->event_source = sd_event_source_unref(s->event_source);
|
2014-03-18 19:22:43 +01:00
|
|
|
s->inotify_fd = safe_close(s->inotify_fd);
|
2010-11-15 21:30:52 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
int path_spec_fd_event(PathSpec *s, uint32_t revents) {
|
2014-12-23 22:47:16 +01:00
|
|
|
union inotify_event_buffer buffer;
|
2011-12-03 01:38:30 +01:00
|
|
|
struct inotify_event *e;
|
2014-12-10 01:45:43 +01:00
|
|
|
ssize_t l;
|
2011-12-03 01:38:30 +01:00
|
|
|
int r = 0;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (revents != EPOLLIN) {
|
2013-01-05 02:46:49 +01:00
|
|
|
log_error("Got invalid poll event on inotify.");
|
2013-03-01 23:58:56 +01:00
|
|
|
return -EINVAL;
|
2011-12-03 01:38:30 +01:00
|
|
|
}
|
|
|
|
|
2014-12-23 22:47:16 +01:00
|
|
|
l = read(s->inotify_fd, &buffer, sizeof(buffer));
|
2014-12-10 01:45:43 +01:00
|
|
|
if (l < 0) {
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(errno, EAGAIN, EINTR))
|
2014-12-10 01:45:43 +01:00
|
|
|
return 0;
|
2011-12-03 01:38:30 +01:00
|
|
|
|
2014-11-28 19:57:32 +01:00
|
|
|
return log_error_errno(errno, "Failed to read inotify event: %m");
|
2014-12-10 01:45:43 +01:00
|
|
|
}
|
2011-12-03 01:38:30 +01:00
|
|
|
|
2014-12-10 01:45:43 +01:00
|
|
|
FOREACH_INOTIFY_EVENT(e, buffer, l) {
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(s->type, PATH_CHANGED, PATH_MODIFIED) &&
|
2011-12-08 12:09:10 +01:00
|
|
|
s->primary_wd == e->wd)
|
2011-12-03 01:38:30 +01:00
|
|
|
r = 1;
|
|
|
|
}
|
2013-03-01 23:58:56 +01:00
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
static bool path_spec_check_good(PathSpec *s, bool initial) {
|
2011-12-03 01:38:30 +01:00
|
|
|
bool good = false;
|
|
|
|
|
|
|
|
switch (s->type) {
|
|
|
|
|
|
|
|
case PATH_EXISTS:
|
|
|
|
good = access(s->path, F_OK) >= 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PATH_EXISTS_GLOB:
|
|
|
|
good = glob_exists(s->path) > 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PATH_DIRECTORY_NOT_EMPTY: {
|
|
|
|
int k;
|
|
|
|
|
|
|
|
k = dir_is_empty(s->path);
|
|
|
|
good = !(k == -ENOENT || k > 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-12-08 12:09:10 +01:00
|
|
|
case PATH_CHANGED:
|
|
|
|
case PATH_MODIFIED: {
|
2011-12-03 01:38:30 +01:00
|
|
|
bool b;
|
|
|
|
|
|
|
|
b = access(s->path, F_OK) >= 0;
|
|
|
|
good = !initial && b != s->previous_exists;
|
|
|
|
s->previous_exists = b;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
return good;
|
|
|
|
}
|
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
static void path_spec_mkdir(PathSpec *s, mode_t mode) {
|
2011-12-03 01:38:30 +01:00
|
|
|
int r;
|
|
|
|
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(s->type, PATH_EXISTS, PATH_EXISTS_GLOB))
|
2011-12-03 01:38:30 +01:00
|
|
|
return;
|
|
|
|
|
2013-01-05 02:46:49 +01:00
|
|
|
r = mkdir_p_label(s->path, mode);
|
|
|
|
if (r < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_warning_errno(r, "mkdir(%s) failed: %m", s->path);
|
2011-12-03 01:38:30 +01:00
|
|
|
}
|
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
|
2011-12-03 01:38:30 +01:00
|
|
|
fprintf(f,
|
|
|
|
"%s%s: %s\n",
|
|
|
|
prefix,
|
|
|
|
path_type_to_string(s->type),
|
|
|
|
s->path);
|
|
|
|
}
|
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
void path_spec_done(PathSpec *s) {
|
|
|
|
assert(s);
|
2011-12-03 01:38:30 +01:00
|
|
|
assert(s->inotify_fd == -1);
|
2012-01-06 23:08:54 +01:00
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
free(s->path);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void path_init(Unit *u) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2011-12-03 01:38:30 +01:00
|
|
|
|
|
|
|
p->directory_mode = 0755;
|
|
|
|
}
|
|
|
|
|
2013-01-17 02:27:06 +01:00
|
|
|
void path_free_specs(Path *p) {
|
2010-05-24 05:25:33 +02:00
|
|
|
PathSpec *s;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
while ((s = p->specs)) {
|
2013-11-19 21:12:59 +01:00
|
|
|
path_spec_unwatch(s);
|
2013-10-14 06:10:14 +02:00
|
|
|
LIST_REMOVE(spec, p->specs, s);
|
2012-01-06 23:08:54 +01:00
|
|
|
path_spec_done(s);
|
2010-05-24 05:25:33 +02:00
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-17 02:27:06 +01:00
|
|
|
static void path_done(Unit *u) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
path_free_specs(p);
|
|
|
|
}
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
static int path_add_mount_links(Path *p) {
|
2010-05-24 05:25:33 +02:00
|
|
|
PathSpec *s;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
LIST_FOREACH(spec, s, p->specs) {
|
2013-09-26 20:14:24 +02:00
|
|
|
r = unit_require_mounts_for(UNIT(p), s->path);
|
2013-03-02 00:04:36 +01:00
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
2013-03-02 00:04:36 +01:00
|
|
|
}
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int path_verify(Path *p) {
|
|
|
|
assert(p);
|
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(p)->load_state != UNIT_LOADED)
|
2010-05-24 05:25:33 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!p->specs) {
|
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(p), "Path unit lacks path setting. Refusing.");
|
2010-05-24 05:25:33 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-16 18:57:21 +02:00
|
|
|
static int path_add_default_dependencies(Path *p) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
if (!UNIT(p)->default_dependencies)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_PATHS_TARGET, NULL, true);
|
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(p)->manager)) {
|
2015-11-11 20:42:39 +01:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
|
2013-03-02 00:04:36 +01:00
|
|
|
if (r < 0)
|
2010-07-16 18:57:21 +02:00
|
|
|
return r;
|
2010-10-29 06:04:03 +02:00
|
|
|
}
|
2010-07-16 18:57:21 +02:00
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
|
2010-07-16 18:57:21 +02:00
|
|
|
}
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
static int path_load(Unit *u) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
r = unit_load_fragment_and_dropin(u);
|
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->load_state == UNIT_LOADED) {
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
|
2012-01-06 23:08:54 +01:00
|
|
|
Unit *x;
|
|
|
|
|
|
|
|
r = unit_load_related_unit(u, ".service", &x);
|
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-01-06 23:08:54 +01:00
|
|
|
}
|
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
r = path_add_mount_links(p);
|
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
2010-07-03 19:48:33 +02:00
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
r = path_add_default_dependencies(p);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return path_verify(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void path_dump(Unit *u, FILE *f, const char *prefix) {
|
|
|
|
Path *p = PATH(u);
|
2013-04-23 20:53:16 +02:00
|
|
|
Unit *trigger;
|
2010-05-24 05:25:33 +02:00
|
|
|
PathSpec *s;
|
|
|
|
|
2010-08-11 22:04:22 +02:00
|
|
|
assert(p);
|
|
|
|
assert(f);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
trigger = UNIT_TRIGGER(u);
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
fprintf(f,
|
|
|
|
"%sPath State: %s\n"
|
2012-02-03 05:04:48 +01:00
|
|
|
"%sResult: %s\n"
|
2011-04-10 01:30:14 +02:00
|
|
|
"%sUnit: %s\n"
|
|
|
|
"%sMakeDirectory: %s\n"
|
|
|
|
"%sDirectoryMode: %04o\n",
|
2010-05-24 05:25:33 +02:00
|
|
|
prefix, path_state_to_string(p->state),
|
2012-02-03 05:04:48 +01:00
|
|
|
prefix, path_result_to_string(p->result),
|
2013-04-23 20:53:16 +02:00
|
|
|
prefix, trigger ? trigger->id : "n/a",
|
2011-04-10 01:30:14 +02:00
|
|
|
prefix, yes_no(p->make_directory),
|
|
|
|
prefix, p->directory_mode);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
LIST_FOREACH(spec, s, p->specs)
|
2012-01-06 23:08:54 +01:00
|
|
|
path_spec_dump(s, f, prefix);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void path_unwatch(Path *p) {
|
|
|
|
PathSpec *s;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
LIST_FOREACH(spec, s, p->specs)
|
2013-11-19 21:12:59 +01:00
|
|
|
path_spec_unwatch(s);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int path_watch(Path *p) {
|
|
|
|
int r;
|
|
|
|
PathSpec *s;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
LIST_FOREACH(spec, s, p->specs) {
|
2013-11-19 21:12:59 +01:00
|
|
|
r = path_spec_watch(s, path_dispatch_io);
|
2013-03-02 00:04:36 +01:00
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
2013-03-02 00:04:36 +01:00
|
|
|
}
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void path_set_state(Path *p, PathState state) {
|
|
|
|
PathState old_state;
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
old_state = p->state;
|
|
|
|
p->state = state;
|
|
|
|
|
2010-11-15 00:49:21 +01:00
|
|
|
if (state != PATH_WAITING &&
|
|
|
|
(state != PATH_RUNNING || p->inotify_triggered))
|
2010-05-24 05:25:33 +02:00
|
|
|
path_unwatch(p);
|
|
|
|
|
|
|
|
if (state != old_state)
|
2015-07-11 01:40:46 +02:00
|
|
|
log_unit_debug(UNIT(p), "Changed %s -> %s", path_state_to_string(old_state), path_state_to_string(state));
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2011-01-20 13:17:22 +01:00
|
|
|
unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
static void path_enter_waiting(Path *p, bool initial, bool recheck);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2015-04-24 15:27:19 +02:00
|
|
|
static int path_coldplug(Unit *u) {
|
2010-05-24 05:25:33 +02:00
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
assert(p->state == PATH_DEAD);
|
|
|
|
|
|
|
|
if (p->deserialized_state != p->state) {
|
|
|
|
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(p->deserialized_state, PATH_WAITING, PATH_RUNNING))
|
2015-04-24 15:27:19 +02:00
|
|
|
path_enter_waiting(p, true, true);
|
|
|
|
else
|
2010-05-24 05:25:33 +02:00
|
|
|
path_set_state(p, p->deserialized_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
static void path_enter_dead(Path *p, PathResult f) {
|
2010-05-24 05:25:33 +02:00
|
|
|
assert(p);
|
|
|
|
|
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 (p->result == PATH_SUCCESS)
|
2012-02-03 05:04:48 +01:00
|
|
|
p->result = f;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2017-09-26 23:35:58 +02:00
|
|
|
if (p->result != PATH_SUCCESS)
|
|
|
|
log_unit_warning(UNIT(p), "Failed with result '%s'.", path_result_to_string(p->result));
|
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void path_enter_running(Path *p) {
|
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 05:25:33 +02:00
|
|
|
int r;
|
2010-07-08 02:43:18 +02:00
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
assert(p);
|
2013-04-23 20:53:16 +02:00
|
|
|
|
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(p)))
|
2010-07-13 00:27:27 +02:00
|
|
|
return;
|
|
|
|
|
2016-02-10 23:39:31 +01:00
|
|
|
trigger = UNIT_TRIGGER(UNIT(p));
|
|
|
|
if (!trigger) {
|
|
|
|
log_unit_error(UNIT(p), "Unit to trigger vanished.");
|
2016-02-11 19:02:54 +01:00
|
|
|
path_enter_dead(p, PATH_FAILURE_RESOURCES);
|
2016-02-10 23:39:31 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = manager_add_job(UNIT(p)->manager, JOB_START, trigger, JOB_REPLACE, &error, NULL);
|
2013-03-02 00:04:36 +01:00
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
goto fail;
|
|
|
|
|
2010-11-15 00:49:21 +01:00
|
|
|
p->inotify_triggered = false;
|
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
r = path_watch(p);
|
|
|
|
if (r < 0)
|
2010-11-15 00:49:21 +01:00
|
|
|
goto fail;
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
path_set_state(p, PATH_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(p), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
|
2012-02-03 05:04:48 +01:00
|
|
|
path_enter_dead(p, PATH_FAILURE_RESOURCES);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
static bool path_check_good(Path *p, bool initial) {
|
2010-05-24 05:25:33 +02:00
|
|
|
PathSpec *s;
|
|
|
|
bool good = false;
|
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
assert(p);
|
2010-11-15 00:49:21 +01:00
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
LIST_FOREACH(spec, s, p->specs) {
|
2012-01-06 23:08:54 +01:00
|
|
|
good = path_spec_check_good(s, initial);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
if (good)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
return good;
|
|
|
|
}
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
static void path_enter_waiting(Path *p, bool initial, bool recheck) {
|
|
|
|
int r;
|
2011-03-04 01:49:37 +01:00
|
|
|
|
2011-04-28 03:22:05 +02:00
|
|
|
if (recheck)
|
|
|
|
if (path_check_good(p, initial)) {
|
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(p), "Got triggered.");
|
2011-04-28 03:22:05 +02:00
|
|
|
path_enter_running(p);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
r = path_watch(p);
|
|
|
|
if (r < 0)
|
2011-04-28 03:22:05 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* Hmm, so now we have created inotify watches, but the file
|
|
|
|
* might have appeared/been removed by now, so we must
|
|
|
|
* recheck */
|
|
|
|
|
|
|
|
if (recheck)
|
|
|
|
if (path_check_good(p, false)) {
|
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(p), "Got triggered.");
|
2011-04-28 03:22:05 +02:00
|
|
|
path_enter_running(p);
|
|
|
|
return;
|
|
|
|
}
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
path_set_state(p, PATH_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(p), r, "Failed to enter waiting state: %m");
|
2012-02-03 05:04:48 +01:00
|
|
|
path_enter_dead(p, PATH_FAILURE_RESOURCES);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
2011-04-10 01:30:14 +02:00
|
|
|
static void path_mkdir(Path *p) {
|
|
|
|
PathSpec *s;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
if (!p->make_directory)
|
|
|
|
return;
|
|
|
|
|
2011-12-03 01:38:30 +01:00
|
|
|
LIST_FOREACH(spec, s, p->specs)
|
2012-01-06 23:08:54 +01:00
|
|
|
path_spec_mkdir(s, p->directory_mode);
|
2011-04-10 01:30:14 +02:00
|
|
|
}
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
static int path_start(Unit *u) {
|
|
|
|
Path *p = PATH(u);
|
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 05:25:33 +02:00
|
|
|
|
|
|
|
assert(p);
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(p->state, PATH_DEAD, PATH_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 05:25:33 +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) {
|
|
|
|
path_enter_dead(p, PATH_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;
|
|
|
|
|
2011-04-10 01:30:14 +02:00
|
|
|
path_mkdir(p);
|
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
p->result = PATH_SUCCESS;
|
2011-04-28 03:22:05 +02:00
|
|
|
path_enter_waiting(p, true, true);
|
2010-10-08 02:31:36 +02:00
|
|
|
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int path_stop(Unit *u) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(p);
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(p->state, PATH_WAITING, PATH_RUNNING));
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
path_enter_dead(p, PATH_SUCCESS);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
unit_serialize_item(u, f, "state", path_state_to_string(p->state));
|
2012-02-03 05:04:48 +01:00
|
|
|
unit_serialize_item(u, f, "result", path_result_to_string(p->result));
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
|
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(key);
|
|
|
|
assert(value);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
if (streq(key, "state")) {
|
|
|
|
PathState state;
|
|
|
|
|
2013-03-02 00:04:36 +01:00
|
|
|
state = path_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 05:25:33 +02:00
|
|
|
else
|
|
|
|
p->deserialized_state = state;
|
2012-02-03 05:04:48 +01:00
|
|
|
|
|
|
|
} else if (streq(key, "result")) {
|
|
|
|
PathResult f;
|
|
|
|
|
|
|
|
f = path_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 05:04:48 +01:00
|
|
|
else if (f != PATH_SUCCESS)
|
|
|
|
p->result = f;
|
|
|
|
|
2010-05-24 05:25:33 +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-24 05:25:33 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static UnitActiveState path_active_state(Unit *u) {
|
2010-05-24 05:25:33 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return state_translation_table[PATH(u)->state];
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static const char *path_sub_state_to_string(Unit *u) {
|
2010-05-24 05:25:33 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return path_state_to_string(PATH(u)->state);
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
PathSpec *s = userdata;
|
|
|
|
Path *p;
|
2011-12-03 01:38:30 +01:00
|
|
|
int changed;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(s);
|
|
|
|
assert(s->unit);
|
2010-05-24 05:25:33 +02:00
|
|
|
assert(fd >= 0);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
p = PATH(s->unit);
|
|
|
|
|
2017-09-29 09:58:22 +02:00
|
|
|
if (!IN_SET(p->state, PATH_WAITING, PATH_RUNNING))
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
/* log_debug("inotify wakeup on %s.", u->id); */
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
LIST_FOREACH(spec, s, p->specs)
|
2012-01-06 23:08:54 +01:00
|
|
|
if (path_spec_owns_inotify_fd(s, fd))
|
2010-05-24 05:25:33 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (!s) {
|
|
|
|
log_error("Got event on unknown fd.");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
changed = path_spec_fd_event(s, revents);
|
2011-12-03 01:38:30 +01:00
|
|
|
if (changed < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
goto fail;
|
|
|
|
|
2010-11-15 00:49:21 +01:00
|
|
|
/* If we are already running, then remember that one event was
|
|
|
|
* dispatched so that we restart the service only if something
|
|
|
|
* actually changed on disk */
|
|
|
|
p->inotify_triggered = true;
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
path_enter_running(p);
|
|
|
|
else
|
2011-04-28 03:22:05 +02:00
|
|
|
path_enter_waiting(p, false, true);
|
2010-11-15 00:49:21 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
|
|
|
fail:
|
2012-02-03 05:04:48 +01:00
|
|
|
path_enter_dead(p, PATH_FAILURE_RESOURCES);
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
static void path_trigger_notify(Unit *u, Unit *other) {
|
|
|
|
Path *p = PATH(u);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
assert(u);
|
|
|
|
assert(other);
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
/* Invoked whenever the unit we trigger changes state or gains
|
|
|
|
* or loses a job */
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
if (other->load_state != UNIT_LOADED)
|
|
|
|
return;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
if (p->state == PATH_RUNNING &&
|
|
|
|
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(p), "Got notified about unit deactivation.");
|
2010-11-15 00:49:21 +01:00
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
/* Hmm, so inotify was triggered since the
|
|
|
|
* last activation, so I guess we need to
|
|
|
|
* recheck what is going on. */
|
|
|
|
path_enter_waiting(p, false, p->inotify_triggered);
|
2010-05-24 05:25:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
static void path_reset_failed(Unit *u) {
|
2010-07-18 04:58:01 +02:00
|
|
|
Path *p = PATH(u);
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
if (p->state == PATH_FAILED)
|
2010-07-18 04:58:01 +02:00
|
|
|
path_set_state(p, PATH_DEAD);
|
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
p->result = PATH_SUCCESS;
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
static const char* const path_type_table[_PATH_TYPE_MAX] = {
|
|
|
|
[PATH_EXISTS] = "PathExists",
|
2011-07-07 02:07:39 +02:00
|
|
|
[PATH_EXISTS_GLOB] = "PathExistsGlob",
|
2014-03-07 21:38:48 +01:00
|
|
|
[PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
|
2010-05-24 05:25:33 +02:00
|
|
|
[PATH_CHANGED] = "PathChanged",
|
2011-12-03 10:22:26 +01:00
|
|
|
[PATH_MODIFIED] = "PathModified",
|
2010-05-24 05:25:33 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
|
|
|
|
|
2012-02-03 05:04:48 +01:00
|
|
|
static const char* const path_result_table[_PATH_RESULT_MAX] = {
|
|
|
|
[PATH_SUCCESS] = "success",
|
2014-03-07 21:38:48 +01:00
|
|
|
[PATH_FAILURE_RESOURCES] = "resources",
|
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
|
|
|
[PATH_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
|
2012-02-03 05:04:48 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
|
|
|
|
|
2010-05-24 05:25:33 +02:00
|
|
|
const UnitVTable path_vtable = {
|
2012-01-15 10:53:49 +01:00
|
|
|
.object_size = sizeof(Path),
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
.sections =
|
|
|
|
"Unit\0"
|
|
|
|
"Path\0"
|
|
|
|
"Install\0",
|
2010-05-24 05:25:33 +02:00
|
|
|
|
2011-04-10 01:30:14 +02:00
|
|
|
.init = path_init,
|
2010-05-24 05:25:33 +02:00
|
|
|
.done = path_done,
|
|
|
|
.load = path_load,
|
|
|
|
|
|
|
|
.coldplug = path_coldplug,
|
|
|
|
|
|
|
|
.dump = path_dump,
|
|
|
|
|
|
|
|
.start = path_start,
|
|
|
|
.stop = path_stop,
|
|
|
|
|
|
|
|
.serialize = path_serialize,
|
|
|
|
.deserialize_item = path_deserialize_item,
|
|
|
|
|
|
|
|
.active_state = path_active_state,
|
|
|
|
.sub_state_to_string = path_sub_state_to_string,
|
|
|
|
|
2013-04-23 20:53:16 +02:00
|
|
|
.trigger_notify = path_trigger_notify,
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
.reset_failed = path_reset_failed,
|
2010-07-18 04:58:01 +02:00
|
|
|
|
2013-12-22 03:43:03 +01:00
|
|
|
.bus_vtable = bus_path_vtable
|
2010-05-24 05:25:33 +02:00
|
|
|
};
|