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 "dbus-common.h"
35 #include "path-util.h"
38 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
39 [PATH_DEAD] = UNIT_INACTIVE,
40 [PATH_WAITING] = UNIT_ACTIVE,
41 [PATH_RUNNING] = UNIT_ACTIVE,
42 [PATH_FAILED] = UNIT_FAILED
45 int path_spec_watch(PathSpec *s, Unit *u) {
47 static const int flags_table[_PATH_TYPE_MAX] = {
48 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
49 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
50 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
51 [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,
52 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
56 char *slash, *oldslash = NULL;
62 path_spec_unwatch(s, u);
64 s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
65 if (s->inotify_fd < 0) {
70 r = unit_watch_fd(u, s->inotify_fd, EPOLLIN, &s->watch);
74 /* This assumes the path was passed through path_kill_slashes()! */
76 for (slash = strchr(s->path, '/'); ; slash = strchr(slash+1, '/')) {
82 cut = slash + (slash == s->path);
86 flags = IN_MOVE_SELF | IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
88 flags = flags_table[s->type];
90 r = inotify_add_watch(s->inotify_fd, s->path, flags);
92 if (errno == EACCES || errno == ENOENT) {
98 log_warning("Failed to add watch on %s: %m", s->path);
106 /* Path exists, we don't need to watch parent
109 char *cut2 = oldslash + (oldslash == s->path);
113 inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
114 /* Error is ignored, the worst can happen is
115 we get spurious events. */
127 /* whole path has been iterated over */
134 log_error("Failed to add watch on any of the components of %s: %m",
136 r = -errno; /* either EACCESS or ENOENT */
143 path_spec_unwatch(s, u);
147 void path_spec_unwatch(PathSpec *s, Unit *u) {
149 if (s->inotify_fd < 0)
152 unit_unwatch_fd(u, &s->watch);
154 close_nointr_nofail(s->inotify_fd);
158 int path_spec_fd_event(PathSpec *s, uint32_t events) {
159 _cleanup_free_ uint8_t *buf = NULL;
160 struct inotify_event *e;
165 if (events != EPOLLIN) {
166 log_error("Got invalid poll event on inotify.");
170 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
171 log_error("FIONREAD failed: %m");
181 k = read(s->inotify_fd, buf, l);
183 log_error("Failed to read inotify event: %m");
187 e = (struct inotify_event*) buf;
192 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
193 s->primary_wd == e->wd)
196 step = sizeof(struct inotify_event) + e->len;
197 assert(step <= (size_t) k);
199 e = (struct inotify_event*) ((uint8_t*) e + step);
206 static bool path_spec_check_good(PathSpec *s, bool initial) {
212 good = access(s->path, F_OK) >= 0;
215 case PATH_EXISTS_GLOB:
216 good = glob_exists(s->path) > 0;
219 case PATH_DIRECTORY_NOT_EMPTY: {
222 k = dir_is_empty(s->path);
223 good = !(k == -ENOENT || k > 0);
228 case PATH_MODIFIED: {
231 b = access(s->path, F_OK) >= 0;
232 good = !initial && b != s->previous_exists;
233 s->previous_exists = b;
244 static bool path_spec_startswith(PathSpec *s, const char *what) {
245 return path_startswith(s->path, what);
248 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
251 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
254 r = mkdir_p_label(s->path, mode);
256 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
259 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
263 path_type_to_string(s->type),
267 void path_spec_done(PathSpec *s) {
269 assert(s->inotify_fd == -1);
274 static void path_init(Unit *u) {
278 assert(u->load_state == UNIT_STUB);
280 p->directory_mode = 0755;
283 void path_free_specs(Path *p) {
288 while ((s = p->specs)) {
289 path_spec_unwatch(s, UNIT(p));
290 LIST_REMOVE(PathSpec, spec, p->specs, s);
296 static void path_done(Unit *u) {
301 unit_ref_unset(&p->unit);
305 int path_add_one_mount_link(Path *p, Mount *m) {
312 if (UNIT(p)->load_state != UNIT_LOADED ||
313 UNIT(m)->load_state != UNIT_LOADED)
316 LIST_FOREACH(spec, s, p->specs) {
317 if (!path_spec_startswith(s, m->where))
320 r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
329 static int path_add_mount_links(Path *p) {
335 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT]) {
336 r = path_add_one_mount_link(p, MOUNT(other));
344 static int path_verify(Path *p) {
347 if (UNIT(p)->load_state != UNIT_LOADED)
351 log_error_unit(UNIT(p)->id,
352 "%s lacks path setting. Refusing.", UNIT(p)->id);
359 static int path_add_default_dependencies(Path *p) {
364 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
365 SPECIAL_PATHS_TARGET, NULL, true);
369 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
370 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
371 SPECIAL_SYSINIT_TARGET, NULL, true);
376 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
377 SPECIAL_SHUTDOWN_TARGET, NULL, true);
380 static int path_load(Unit *u) {
385 assert(u->load_state == UNIT_STUB);
387 r = unit_load_fragment_and_dropin(u);
391 if (u->load_state == UNIT_LOADED) {
393 if (!UNIT_DEREF(p->unit)) {
396 r = unit_load_related_unit(u, ".service", &x);
400 unit_ref_set(&p->unit, x);
403 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS,
404 UNIT_DEREF(p->unit), true);
408 r = path_add_mount_links(p);
412 if (UNIT(p)->default_dependencies) {
413 r = path_add_default_dependencies(p);
419 return path_verify(p);
422 static void path_dump(Unit *u, FILE *f, const char *prefix) {
433 "%sMakeDirectory: %s\n"
434 "%sDirectoryMode: %04o\n",
435 prefix, path_state_to_string(p->state),
436 prefix, path_result_to_string(p->result),
437 prefix, UNIT_DEREF(p->unit)->id,
438 prefix, yes_no(p->make_directory),
439 prefix, p->directory_mode);
441 LIST_FOREACH(spec, s, p->specs)
442 path_spec_dump(s, f, prefix);
445 static void path_unwatch(Path *p) {
450 LIST_FOREACH(spec, s, p->specs)
451 path_spec_unwatch(s, UNIT(p));
454 static int path_watch(Path *p) {
460 LIST_FOREACH(spec, s, p->specs) {
461 r = path_spec_watch(s, UNIT(p));
469 static void path_set_state(Path *p, PathState state) {
473 old_state = p->state;
476 if (state != PATH_WAITING &&
477 (state != PATH_RUNNING || p->inotify_triggered))
480 if (state != old_state)
481 log_debug("%s changed %s -> %s",
483 path_state_to_string(old_state),
484 path_state_to_string(state));
486 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
489 static void path_enter_waiting(Path *p, bool initial, bool recheck);
491 static int path_coldplug(Unit *u) {
495 assert(p->state == PATH_DEAD);
497 if (p->deserialized_state != p->state) {
499 if (p->deserialized_state == PATH_WAITING ||
500 p->deserialized_state == PATH_RUNNING)
501 path_enter_waiting(p, true, true);
503 path_set_state(p, p->deserialized_state);
509 static void path_enter_dead(Path *p, PathResult f) {
512 if (f != PATH_SUCCESS)
515 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
518 static void path_enter_running(Path *p) {
523 dbus_error_init(&error);
525 /* Don't start job if we are supposed to go down */
526 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
529 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit),
530 JOB_REPLACE, true, &error, NULL);
534 p->inotify_triggered = false;
540 path_set_state(p, PATH_RUNNING);
544 log_warning("%s failed to queue unit startup job: %s",
545 UNIT(p)->id, bus_error(&error, r));
546 path_enter_dead(p, PATH_FAILURE_RESOURCES);
548 dbus_error_free(&error);
551 static bool path_check_good(Path *p, bool initial) {
557 LIST_FOREACH(spec, s, p->specs) {
558 good = path_spec_check_good(s, initial);
567 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
571 if (path_check_good(p, initial)) {
572 log_debug("%s got triggered.", UNIT(p)->id);
573 path_enter_running(p);
581 /* Hmm, so now we have created inotify watches, but the file
582 * might have appeared/been removed by now, so we must
586 if (path_check_good(p, false)) {
587 log_debug("%s got triggered.", UNIT(p)->id);
588 path_enter_running(p);
592 path_set_state(p, PATH_WAITING);
596 log_warning("%s failed to enter waiting state: %s",
597 UNIT(p)->id, strerror(-r));
598 path_enter_dead(p, PATH_FAILURE_RESOURCES);
601 static void path_mkdir(Path *p) {
606 if (!p->make_directory)
609 LIST_FOREACH(spec, s, p->specs)
610 path_spec_mkdir(s, p->directory_mode);
613 static int path_start(Unit *u) {
617 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
619 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
624 p->result = PATH_SUCCESS;
625 path_enter_waiting(p, true, true);
630 static int path_stop(Unit *u) {
634 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
636 path_enter_dead(p, PATH_SUCCESS);
640 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
647 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
648 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
653 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
661 if (streq(key, "state")) {
664 state = path_state_from_string(value);
666 log_debug("Failed to parse state value %s", value);
668 p->deserialized_state = state;
670 } else if (streq(key, "result")) {
673 f = path_result_from_string(value);
675 log_debug("Failed to parse result value %s", value);
676 else if (f != PATH_SUCCESS)
680 log_debug("Unknown serialization key '%s'", key);
685 static UnitActiveState path_active_state(Unit *u) {
688 return state_translation_table[PATH(u)->state];
691 static const char *path_sub_state_to_string(Unit *u) {
694 return path_state_to_string(PATH(u)->state);
697 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
705 if (p->state != PATH_WAITING &&
706 p->state != PATH_RUNNING)
709 /* log_debug("inotify wakeup on %s.", u->id); */
711 LIST_FOREACH(spec, s, p->specs)
712 if (path_spec_owns_inotify_fd(s, fd))
716 log_error("Got event on unknown fd.");
720 changed = path_spec_fd_event(s, events);
724 /* If we are already running, then remember that one event was
725 * dispatched so that we restart the service only if something
726 * actually changed on disk */
727 p->inotify_triggered = true;
730 path_enter_running(p);
732 path_enter_waiting(p, false, true);
737 path_enter_dead(p, PATH_FAILURE_RESOURCES);
740 void path_unit_notify(Unit *u, UnitActiveState new_state) {
744 if (u->type == UNIT_PATH)
747 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
750 if (k->type != UNIT_PATH)
753 if (k->load_state != UNIT_LOADED)
758 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
759 log_debug("%s got notified about unit deactivation.",
762 /* Hmm, so inotify was triggered since the
763 * last activation, so I guess we need to
764 * recheck what is going on. */
765 path_enter_waiting(p, false, p->inotify_triggered);
770 static void path_reset_failed(Unit *u) {
775 if (p->state == PATH_FAILED)
776 path_set_state(p, PATH_DEAD);
778 p->result = PATH_SUCCESS;
781 static const char* const path_state_table[_PATH_STATE_MAX] = {
782 [PATH_DEAD] = "dead",
783 [PATH_WAITING] = "waiting",
784 [PATH_RUNNING] = "running",
785 [PATH_FAILED] = "failed"
788 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
790 static const char* const path_type_table[_PATH_TYPE_MAX] = {
791 [PATH_EXISTS] = "PathExists",
792 [PATH_EXISTS_GLOB] = "PathExistsGlob",
793 [PATH_CHANGED] = "PathChanged",
794 [PATH_MODIFIED] = "PathModified",
795 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
798 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
800 static const char* const path_result_table[_PATH_RESULT_MAX] = {
801 [PATH_SUCCESS] = "success",
802 [PATH_FAILURE_RESOURCES] = "resources"
805 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
807 const UnitVTable path_vtable = {
808 .object_size = sizeof(Path),
818 .coldplug = path_coldplug,
825 .serialize = path_serialize,
826 .deserialize_item = path_deserialize_item,
828 .active_state = path_active_state,
829 .sub_state_to_string = path_sub_state_to_string,
831 .fd_event = path_fd_event,
833 .reset_failed = path_reset_failed,
835 .bus_interface = "org.freedesktop.systemd1.Path",
836 .bus_message_handler = bus_path_message_handler,
837 .bus_invalidating_properties = bus_path_invalidating_properties