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 void path_spec_mkdir(PathSpec *s, mode_t mode) {
247 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
250 r = mkdir_p_label(s->path, mode);
252 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
255 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
259 path_type_to_string(s->type),
263 void path_spec_done(PathSpec *s) {
265 assert(s->inotify_fd == -1);
270 static void path_init(Unit *u) {
274 assert(u->load_state == UNIT_STUB);
276 p->directory_mode = 0755;
279 void path_free_specs(Path *p) {
284 while ((s = p->specs)) {
285 path_spec_unwatch(s, UNIT(p));
286 LIST_REMOVE(spec, p->specs, s);
292 static void path_done(Unit *u) {
300 static int path_add_mount_links(Path *p) {
306 LIST_FOREACH(spec, s, p->specs) {
307 r = unit_require_mounts_for(UNIT(p), s->path);
315 static int path_verify(Path *p) {
318 if (UNIT(p)->load_state != UNIT_LOADED)
322 log_error_unit(UNIT(p)->id,
323 "%s lacks path setting. Refusing.", UNIT(p)->id);
330 static int path_add_default_dependencies(Path *p) {
335 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
336 SPECIAL_PATHS_TARGET, NULL, true);
340 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
341 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
342 SPECIAL_SYSINIT_TARGET, NULL, true);
347 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
348 SPECIAL_SHUTDOWN_TARGET, NULL, true);
351 static int path_load(Unit *u) {
356 assert(u->load_state == UNIT_STUB);
358 r = unit_load_fragment_and_dropin(u);
362 if (u->load_state == UNIT_LOADED) {
364 if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
367 r = unit_load_related_unit(u, ".service", &x);
371 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
376 r = path_add_mount_links(p);
380 if (UNIT(p)->default_dependencies) {
381 r = path_add_default_dependencies(p);
387 return path_verify(p);
390 static void path_dump(Unit *u, FILE *f, const char *prefix) {
398 trigger = UNIT_TRIGGER(u);
404 "%sMakeDirectory: %s\n"
405 "%sDirectoryMode: %04o\n",
406 prefix, path_state_to_string(p->state),
407 prefix, path_result_to_string(p->result),
408 prefix, trigger ? trigger->id : "n/a",
409 prefix, yes_no(p->make_directory),
410 prefix, p->directory_mode);
412 LIST_FOREACH(spec, s, p->specs)
413 path_spec_dump(s, f, prefix);
416 static void path_unwatch(Path *p) {
421 LIST_FOREACH(spec, s, p->specs)
422 path_spec_unwatch(s, UNIT(p));
425 static int path_watch(Path *p) {
431 LIST_FOREACH(spec, s, p->specs) {
432 r = path_spec_watch(s, UNIT(p));
440 static void path_set_state(Path *p, PathState state) {
444 old_state = p->state;
447 if (state != PATH_WAITING &&
448 (state != PATH_RUNNING || p->inotify_triggered))
451 if (state != old_state)
452 log_debug("%s changed %s -> %s",
454 path_state_to_string(old_state),
455 path_state_to_string(state));
457 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
460 static void path_enter_waiting(Path *p, bool initial, bool recheck);
462 static int path_coldplug(Unit *u) {
466 assert(p->state == PATH_DEAD);
468 if (p->deserialized_state != p->state) {
470 if (p->deserialized_state == PATH_WAITING ||
471 p->deserialized_state == PATH_RUNNING)
472 path_enter_waiting(p, true, true);
474 path_set_state(p, p->deserialized_state);
480 static void path_enter_dead(Path *p, PathResult f) {
483 if (f != PATH_SUCCESS)
486 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
489 static void path_enter_running(Path *p) {
490 _cleanup_dbus_error_free_ DBusError error;
495 dbus_error_init(&error);
497 /* Don't start job if we are supposed to go down */
498 if (unit_stop_pending(UNIT(p)))
501 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_TRIGGER(UNIT(p)),
502 JOB_REPLACE, true, &error, NULL);
506 p->inotify_triggered = false;
512 path_set_state(p, PATH_RUNNING);
516 log_warning("%s failed to queue unit startup job: %s",
517 UNIT(p)->id, bus_error(&error, r));
518 path_enter_dead(p, PATH_FAILURE_RESOURCES);
521 static bool path_check_good(Path *p, bool initial) {
527 LIST_FOREACH(spec, s, p->specs) {
528 good = path_spec_check_good(s, initial);
537 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
541 if (path_check_good(p, initial)) {
542 log_debug("%s got triggered.", UNIT(p)->id);
543 path_enter_running(p);
551 /* Hmm, so now we have created inotify watches, but the file
552 * might have appeared/been removed by now, so we must
556 if (path_check_good(p, false)) {
557 log_debug("%s got triggered.", UNIT(p)->id);
558 path_enter_running(p);
562 path_set_state(p, PATH_WAITING);
566 log_warning("%s failed to enter waiting state: %s",
567 UNIT(p)->id, strerror(-r));
568 path_enter_dead(p, PATH_FAILURE_RESOURCES);
571 static void path_mkdir(Path *p) {
576 if (!p->make_directory)
579 LIST_FOREACH(spec, s, p->specs)
580 path_spec_mkdir(s, p->directory_mode);
583 static int path_start(Unit *u) {
587 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
589 if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
594 p->result = PATH_SUCCESS;
595 path_enter_waiting(p, true, true);
600 static int path_stop(Unit *u) {
604 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
606 path_enter_dead(p, PATH_SUCCESS);
610 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
617 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
618 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
623 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
631 if (streq(key, "state")) {
634 state = path_state_from_string(value);
636 log_debug("Failed to parse state value %s", value);
638 p->deserialized_state = state;
640 } else if (streq(key, "result")) {
643 f = path_result_from_string(value);
645 log_debug("Failed to parse result value %s", value);
646 else if (f != PATH_SUCCESS)
650 log_debug("Unknown serialization key '%s'", key);
655 _pure_ static UnitActiveState path_active_state(Unit *u) {
658 return state_translation_table[PATH(u)->state];
661 _pure_ static const char *path_sub_state_to_string(Unit *u) {
664 return path_state_to_string(PATH(u)->state);
667 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
675 if (p->state != PATH_WAITING &&
676 p->state != PATH_RUNNING)
679 /* log_debug("inotify wakeup on %s.", u->id); */
681 LIST_FOREACH(spec, s, p->specs)
682 if (path_spec_owns_inotify_fd(s, fd))
686 log_error("Got event on unknown fd.");
690 changed = path_spec_fd_event(s, events);
694 /* If we are already running, then remember that one event was
695 * dispatched so that we restart the service only if something
696 * actually changed on disk */
697 p->inotify_triggered = true;
700 path_enter_running(p);
702 path_enter_waiting(p, false, true);
707 path_enter_dead(p, PATH_FAILURE_RESOURCES);
710 static void path_trigger_notify(Unit *u, Unit *other) {
716 /* Invoked whenever the unit we trigger changes state or gains
719 if (other->load_state != UNIT_LOADED)
722 if (p->state == PATH_RUNNING &&
723 UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
724 log_debug_unit(UNIT(p)->id,
725 "%s got notified about unit deactivation.",
728 /* Hmm, so inotify was triggered since the
729 * last activation, so I guess we need to
730 * recheck what is going on. */
731 path_enter_waiting(p, false, p->inotify_triggered);
735 static void path_reset_failed(Unit *u) {
740 if (p->state == PATH_FAILED)
741 path_set_state(p, PATH_DEAD);
743 p->result = PATH_SUCCESS;
746 static const char* const path_state_table[_PATH_STATE_MAX] = {
747 [PATH_DEAD] = "dead",
748 [PATH_WAITING] = "waiting",
749 [PATH_RUNNING] = "running",
750 [PATH_FAILED] = "failed"
753 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
755 static const char* const path_type_table[_PATH_TYPE_MAX] = {
756 [PATH_EXISTS] = "PathExists",
757 [PATH_EXISTS_GLOB] = "PathExistsGlob",
758 [PATH_CHANGED] = "PathChanged",
759 [PATH_MODIFIED] = "PathModified",
760 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
763 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
765 static const char* const path_result_table[_PATH_RESULT_MAX] = {
766 [PATH_SUCCESS] = "success",
767 [PATH_FAILURE_RESOURCES] = "resources"
770 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
772 const UnitVTable path_vtable = {
773 .object_size = sizeof(Path),
783 .coldplug = path_coldplug,
790 .serialize = path_serialize,
791 .deserialize_item = path_deserialize_item,
793 .active_state = path_active_state,
794 .sub_state_to_string = path_sub_state_to_string,
796 .fd_event = path_fd_event,
798 .trigger_notify = path_trigger_notify,
800 .reset_failed = path_reset_failed,
802 .bus_interface = "org.freedesktop.systemd1.Path",
803 .bus_message_handler = bus_path_message_handler,
804 .bus_invalidating_properties = bus_path_invalidating_properties