-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
[PATH_DEAD] = UNIT_INACTIVE,
[PATH_WAITING] = UNIT_ACTIVE,
[PATH_RUNNING] = UNIT_ACTIVE,
- [PATH_MAINTENANCE] = UNIT_MAINTENANCE
+ [PATH_FAILED] = UNIT_FAILED
};
+static void path_unwatch_one(Path *p, PathSpec *s) {
+
+ if (s->inotify_fd < 0)
+ return;
+
+ unit_unwatch_fd(UNIT(p), &s->watch);
+
+ close_nointr_nofail(s->inotify_fd);
+ s->inotify_fd = -1;
+}
+
static void path_done(Unit *u) {
Path *p = PATH(u);
PathSpec *s;
assert(p);
while ((s = p->specs)) {
+ path_unwatch_one(p, s);
LIST_REMOVE(PathSpec, spec, p->specs, s);
+ free(s->path);
free(s);
}
}
return 0;
}
+static int path_add_default_dependencies(Path *p) {
+ int r;
+
+ assert(p);
+
+ if (p->meta.manager->running_as == MANAGER_SYSTEM) {
+ if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
+ return r;
+
+ if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
+ return r;
+ }
+
+ return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
+}
+
static int path_load(Unit *u) {
Path *p = PATH(u);
int r;
if ((r = path_add_mount_links(p)) < 0)
return r;
- /* Path units shouldn't stay around on shutdown */
if (p->meta.default_dependencies)
- if ((r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
+ if ((r = path_add_default_dependencies(p)) < 0)
return r;
}
static void path_dump(Unit *u, FILE *f, const char *prefix) {
Path *p = PATH(u);
- const char *prefix2;
- char *p2;
PathSpec *s;
- p2 = strappend(prefix, "\t");
- prefix2 = p2 ? p2 : prefix;
+ assert(p);
+ assert(f);
fprintf(f,
"%sPath State: %s\n"
prefix,
path_type_to_string(s->type),
s->path);
-
- free(p2);
-}
-
-static void path_unwatch_one(Path *p, PathSpec *s) {
-
- if (s->inotify_fd < 0)
- return;
-
- unit_unwatch_fd(UNIT(p), &s->watch);
-
- close_nointr_nofail(s->inotify_fd);
- s->inotify_fd = -1;
}
static int path_watch_one(Path *p, PathSpec *s) {
static const int flags_table[_PATH_TYPE_MAX] = {
- [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF,
+ [PATH_EXISTS] = 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,
- [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_CREATE|IN_MOVED_TO
+ [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
};
bool exists = false;
*slash = 0;
- flags = IN_DELETE_SELF|IN_MOVE_SELF;
+ flags = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB;
if (!exists)
- flags |= IN_CREATE | IN_MOVED_TO | IN_ATTRIB;
+ flags |= IN_CREATE | IN_MOVED_TO;
if (inotify_add_watch(s->inotify_fd, k, flags) >= 0)
exists = true;
old_state = p->state;
p->state = state;
- if (state != PATH_WAITING)
+ if (state != PATH_WAITING &&
+ (state != PATH_RUNNING || p->inotify_triggered))
path_unwatch(p);
if (state != old_state)
unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state]);
}
-static void path_enter_waiting(Path *p, bool initial);
+static void path_enter_waiting(Path *p, bool initial, bool recheck);
static int path_coldplug(Unit *u) {
Path *p = PATH(u);
if (p->deserialized_state == PATH_WAITING ||
p->deserialized_state == PATH_RUNNING)
- path_enter_waiting(p, true);
+ path_enter_waiting(p, true, true);
else
path_set_state(p, p->deserialized_state);
}
if (!success)
p->failure = true;
- path_set_state(p, p->failure ? PATH_MAINTENANCE : PATH_DEAD);
+ path_set_state(p, p->failure ? PATH_FAILED : PATH_DEAD);
}
static void path_enter_running(Path *p) {
if ((r = manager_add_job(p->meta.manager, JOB_START, p->unit, JOB_REPLACE, true, &error, NULL)) < 0)
goto fail;
+ p->inotify_triggered = false;
+
+ if ((r = path_watch(p)) < 0)
+ goto fail;
+
path_set_state(p, PATH_RUNNING);
return;
}
-static void path_enter_waiting(Path *p, bool initial) {
+static void path_enter_waiting(Path *p, bool initial, bool recheck) {
PathSpec *s;
int r;
bool good = false;
+ if (!recheck)
+ goto waiting;
+
LIST_FOREACH(spec, s, p->specs) {
switch (s->type) {
good = access(s->path, F_OK) >= 0;
break;
- case PATH_DIRECTORY_NOT_EMPTY:
- good = dir_is_empty(s->path) == 0;
+ case PATH_DIRECTORY_NOT_EMPTY: {
+ int k;
+
+ k = dir_is_empty(s->path);
+ good = !(k == -ENOENT || k > 0);
break;
+ }
case PATH_CHANGED: {
bool b;
return;
}
+waiting:
if ((r = path_watch(p)) < 0)
goto fail;
Path *p = PATH(u);
assert(p);
- assert(p->state == PATH_DEAD || p->state == PATH_MAINTENANCE);
+ assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
if (p->unit->meta.load_state != UNIT_LOADED)
return -ENOENT;
p->failure = false;
-path_enter_waiting(p, true);
+ path_enter_waiting(p, true, true);
+
return 0;
}
Path *p = PATH(u);
int l;
ssize_t k;
- struct inotify_event *buf = NULL;
+ uint8_t *buf = NULL;
+ struct inotify_event *e;
PathSpec *s;
+ bool changed;
assert(p);
assert(fd >= 0);
- if (p->state != PATH_WAITING)
+ if (p->state != PATH_WAITING &&
+ p->state != PATH_RUNNING)
return;
log_debug("inotify wakeup on %s.", u->meta.id);
goto fail;
}
- if ((size_t) k < sizeof(struct inotify_event) ||
- (size_t) k < sizeof(struct inotify_event) + buf->len) {
- log_error("inotify event too small.");
- goto fail;
+ /* 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;
+
+ e = (struct inotify_event*) buf;
+
+ changed = false;
+ while (k > 0) {
+ size_t step;
+
+ if (s->type == PATH_CHANGED && s->primary_wd == e->wd)
+ changed = true;
+
+ step = sizeof(struct inotify_event) + e->len;
+ assert(step <= (size_t) k);
+
+ e = (struct inotify_event*) ((uint8_t*) e + step);
+ k -= step;
}
- if (s->type == PATH_CHANGED && s->primary_wd == buf->wd)
+ if (changed)
path_enter_running(p);
else
- path_enter_waiting(p, false);
+ path_enter_waiting(p, false, true);
free(buf);
if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
log_debug("%s got notified about unit deactivation.", p->meta.id);
- path_enter_waiting(p, false);
+
+ /* 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);
}
}
log_error("Failed find path unit: %s", strerror(-r));
}
+static void path_reset_failed(Unit *u) {
+ Path *p = PATH(u);
+
+ assert(p);
+
+ if (p->state == PATH_FAILED)
+ path_set_state(p, PATH_DEAD);
+
+ p->failure = false;
+}
+
static const char* const path_state_table[_PATH_STATE_MAX] = {
[PATH_DEAD] = "dead",
[PATH_WAITING] = "waiting",
[PATH_RUNNING] = "running",
- [PATH_MAINTENANCE] = "maintenance"
+ [PATH_FAILED] = "failed"
};
DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
.fd_event = path_fd_event,
+ .reset_failed = path_reset_failed,
+
+ .bus_interface = "org.freedesktop.systemd1.Path",
.bus_message_handler = bus_path_message_handler
};
~ianmdlvl / elogind.git / blobdiff