1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/inotify.h>
23 #include <sys/epoll.h>
24 #include <sys/ioctl.h>
29 #include "unit-name.h"
32 #include "dbus-path.h"
34 #include "path-util.h"
37 #include "bus-error.h"
39 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
40 [PATH_DEAD] = UNIT_INACTIVE,
41 [PATH_WAITING] = UNIT_ACTIVE,
42 [PATH_RUNNING] = UNIT_ACTIVE,
43 [PATH_FAILED] = UNIT_FAILED
46 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
48 int path_spec_watch(PathSpec *s, sd_event_io_handler_t handler) {
50 static const int flags_table[_PATH_TYPE_MAX] = {
51 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
52 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
53 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
54 [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,
55 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
59 char *slash, *oldslash = NULL;
68 s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
69 if (s->inotify_fd < 0) {
74 r = sd_event_add_io(s->unit->manager->event, &s->event_source, s->inotify_fd, EPOLLIN, handler, s);
78 /* This assumes the path was passed through path_kill_slashes()! */
80 for (slash = strchr(s->path, '/'); ; slash = strchr(slash+1, '/')) {
86 cut = slash + (slash == s->path);
90 flags = IN_MOVE_SELF | IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
92 flags = flags_table[s->type];
94 r = inotify_add_watch(s->inotify_fd, s->path, flags);
96 if (errno == EACCES || errno == ENOENT) {
102 log_warning("Failed to add watch on %s: %s", s->path,
103 errno == ENOSPC ? "too many watches" : strerror(-r));
111 /* Path exists, we don't need to watch parent
114 char *cut2 = oldslash + (oldslash == s->path);
118 inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
119 /* Error is ignored, the worst can happen is
120 we get spurious events. */
132 /* whole path has been iterated over */
139 log_error("Failed to add watch on any of the components of %s: %m",
141 r = -errno; /* either EACCESS or ENOENT */
148 path_spec_unwatch(s);
152 void path_spec_unwatch(PathSpec *s) {
155 s->event_source = sd_event_source_unref(s->event_source);
156 s->inotify_fd = safe_close(s->inotify_fd);
159 int path_spec_fd_event(PathSpec *s, uint32_t revents) {
160 _cleanup_free_ uint8_t *buf = NULL;
161 struct inotify_event *e;
166 if (revents != EPOLLIN) {
167 log_error("Got invalid poll event on inotify.");
171 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
172 log_error("FIONREAD failed: %m");
182 k = read(s->inotify_fd, buf, l);
184 log_error("Failed to read inotify event: %m");
188 e = (struct inotify_event*) buf;
193 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
194 s->primary_wd == e->wd)
197 step = sizeof(struct inotify_event) + e->len;
198 assert(step <= (size_t) k);
200 e = (struct inotify_event*) ((uint8_t*) e + step);
207 static bool path_spec_check_good(PathSpec *s, bool initial) {
213 good = access(s->path, F_OK) >= 0;
216 case PATH_EXISTS_GLOB:
217 good = glob_exists(s->path) > 0;
220 case PATH_DIRECTORY_NOT_EMPTY: {
223 k = dir_is_empty(s->path);
224 good = !(k == -ENOENT || k > 0);
229 case PATH_MODIFIED: {
232 b = access(s->path, F_OK) >= 0;
233 good = !initial && b != s->previous_exists;
234 s->previous_exists = b;
245 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
248 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
251 r = mkdir_p_label(s->path, mode);
253 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
256 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
260 path_type_to_string(s->type),
264 void path_spec_done(PathSpec *s) {
266 assert(s->inotify_fd == -1);
271 static void path_init(Unit *u) {
275 assert(u->load_state == UNIT_STUB);
277 p->directory_mode = 0755;
280 void path_free_specs(Path *p) {
285 while ((s = p->specs)) {
286 path_spec_unwatch(s);
287 LIST_REMOVE(spec, p->specs, s);
293 static void path_done(Unit *u) {
301 static int path_add_mount_links(Path *p) {
307 LIST_FOREACH(spec, s, p->specs) {
308 r = unit_require_mounts_for(UNIT(p), s->path);
316 static int path_verify(Path *p) {
319 if (UNIT(p)->load_state != UNIT_LOADED)
323 log_error_unit(UNIT(p)->id,
324 "%s lacks path setting. Refusing.", UNIT(p)->id);
331 static int path_add_default_dependencies(Path *p) {
336 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
337 SPECIAL_PATHS_TARGET, NULL, true);
341 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
342 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
343 SPECIAL_SYSINIT_TARGET, NULL, true);
348 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
349 SPECIAL_SHUTDOWN_TARGET, NULL, true);
352 static int path_load(Unit *u) {
357 assert(u->load_state == UNIT_STUB);
359 r = unit_load_fragment_and_dropin(u);
363 if (u->load_state == UNIT_LOADED) {
365 if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
368 r = unit_load_related_unit(u, ".service", &x);
372 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
377 r = path_add_mount_links(p);
381 if (UNIT(p)->default_dependencies) {
382 r = path_add_default_dependencies(p);
388 return path_verify(p);
391 static void path_dump(Unit *u, FILE *f, const char *prefix) {
399 trigger = UNIT_TRIGGER(u);
405 "%sMakeDirectory: %s\n"
406 "%sDirectoryMode: %04o\n",
407 prefix, path_state_to_string(p->state),
408 prefix, path_result_to_string(p->result),
409 prefix, trigger ? trigger->id : "n/a",
410 prefix, yes_no(p->make_directory),
411 prefix, p->directory_mode);
413 LIST_FOREACH(spec, s, p->specs)
414 path_spec_dump(s, f, prefix);
417 static void path_unwatch(Path *p) {
422 LIST_FOREACH(spec, s, p->specs)
423 path_spec_unwatch(s);
426 static int path_watch(Path *p) {
432 LIST_FOREACH(spec, s, p->specs) {
433 r = path_spec_watch(s, path_dispatch_io);
441 static void path_set_state(Path *p, PathState state) {
445 old_state = p->state;
448 if (state != PATH_WAITING &&
449 (state != PATH_RUNNING || p->inotify_triggered))
452 if (state != old_state)
453 log_debug("%s changed %s -> %s",
455 path_state_to_string(old_state),
456 path_state_to_string(state));
458 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
461 static void path_enter_waiting(Path *p, bool initial, bool recheck);
463 static int path_coldplug(Unit *u) {
467 assert(p->state == PATH_DEAD);
469 if (p->deserialized_state != p->state) {
471 if (p->deserialized_state == PATH_WAITING ||
472 p->deserialized_state == PATH_RUNNING)
473 path_enter_waiting(p, true, true);
475 path_set_state(p, p->deserialized_state);
481 static void path_enter_dead(Path *p, PathResult f) {
484 if (f != PATH_SUCCESS)
487 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
490 static void path_enter_running(Path *p) {
491 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
496 /* Don't start job if we are supposed to go down */
497 if (unit_stop_pending(UNIT(p)))
500 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_TRIGGER(UNIT(p)),
501 JOB_REPLACE, true, &error, NULL);
505 p->inotify_triggered = false;
511 path_set_state(p, PATH_RUNNING);
515 log_warning("%s failed to queue unit startup job: %s",
516 UNIT(p)->id, bus_error_message(&error, r));
517 path_enter_dead(p, PATH_FAILURE_RESOURCES);
520 static bool path_check_good(Path *p, bool initial) {
526 LIST_FOREACH(spec, s, p->specs) {
527 good = path_spec_check_good(s, initial);
536 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
540 if (path_check_good(p, initial)) {
541 log_debug("%s got triggered.", UNIT(p)->id);
542 path_enter_running(p);
550 /* Hmm, so now we have created inotify watches, but the file
551 * might have appeared/been removed by now, so we must
555 if (path_check_good(p, false)) {
556 log_debug("%s got triggered.", UNIT(p)->id);
557 path_enter_running(p);
561 path_set_state(p, PATH_WAITING);
565 log_warning("%s failed to enter waiting state: %s",
566 UNIT(p)->id, strerror(-r));
567 path_enter_dead(p, PATH_FAILURE_RESOURCES);
570 static void path_mkdir(Path *p) {
575 if (!p->make_directory)
578 LIST_FOREACH(spec, s, p->specs)
579 path_spec_mkdir(s, p->directory_mode);
582 static int path_start(Unit *u) {
586 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
588 if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
593 p->result = PATH_SUCCESS;
594 path_enter_waiting(p, true, true);
599 static int path_stop(Unit *u) {
603 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
605 path_enter_dead(p, PATH_SUCCESS);
609 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
616 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
617 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
622 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
630 if (streq(key, "state")) {
633 state = path_state_from_string(value);
635 log_debug("Failed to parse state value %s", value);
637 p->deserialized_state = state;
639 } else if (streq(key, "result")) {
642 f = path_result_from_string(value);
644 log_debug("Failed to parse result value %s", value);
645 else if (f != PATH_SUCCESS)
649 log_debug("Unknown serialization key '%s'", key);
654 _pure_ static UnitActiveState path_active_state(Unit *u) {
657 return state_translation_table[PATH(u)->state];
660 _pure_ static const char *path_sub_state_to_string(Unit *u) {
663 return path_state_to_string(PATH(u)->state);
666 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
667 PathSpec *s = userdata;
677 if (p->state != PATH_WAITING &&
678 p->state != PATH_RUNNING)
681 /* log_debug("inotify wakeup on %s.", u->id); */
683 LIST_FOREACH(spec, s, p->specs)
684 if (path_spec_owns_inotify_fd(s, fd))
688 log_error("Got event on unknown fd.");
692 changed = path_spec_fd_event(s, revents);
696 /* If we are already running, then remember that one event was
697 * dispatched so that we restart the service only if something
698 * actually changed on disk */
699 p->inotify_triggered = true;
702 path_enter_running(p);
704 path_enter_waiting(p, false, true);
709 path_enter_dead(p, PATH_FAILURE_RESOURCES);
713 static void path_trigger_notify(Unit *u, Unit *other) {
719 /* Invoked whenever the unit we trigger changes state or gains
722 if (other->load_state != UNIT_LOADED)
725 if (p->state == PATH_RUNNING &&
726 UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
727 log_debug_unit(UNIT(p)->id,
728 "%s got notified about unit deactivation.",
731 /* Hmm, so inotify was triggered since the
732 * last activation, so I guess we need to
733 * recheck what is going on. */
734 path_enter_waiting(p, false, p->inotify_triggered);
738 static void path_reset_failed(Unit *u) {
743 if (p->state == PATH_FAILED)
744 path_set_state(p, PATH_DEAD);
746 p->result = PATH_SUCCESS;
749 static const char* const path_state_table[_PATH_STATE_MAX] = {
750 [PATH_DEAD] = "dead",
751 [PATH_WAITING] = "waiting",
752 [PATH_RUNNING] = "running",
753 [PATH_FAILED] = "failed"
756 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
758 static const char* const path_type_table[_PATH_TYPE_MAX] = {
759 [PATH_EXISTS] = "PathExists",
760 [PATH_EXISTS_GLOB] = "PathExistsGlob",
761 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
762 [PATH_CHANGED] = "PathChanged",
763 [PATH_MODIFIED] = "PathModified",
766 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
768 static const char* const path_result_table[_PATH_RESULT_MAX] = {
769 [PATH_SUCCESS] = "success",
770 [PATH_FAILURE_RESOURCES] = "resources",
773 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
775 const UnitVTable path_vtable = {
776 .object_size = sizeof(Path),
787 .coldplug = path_coldplug,
794 .serialize = path_serialize,
795 .deserialize_item = path_deserialize_item,
797 .active_state = path_active_state,
798 .sub_state_to_string = path_sub_state_to_string,
800 .trigger_notify = path_trigger_notify,
802 .reset_failed = path_reset_failed,
804 .bus_interface = "org.freedesktop.systemd1.Path",
805 .bus_vtable = bus_path_vtable