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->inotify_fd, EPOLLIN, handler, s, &s->event_source);
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: %m", s->path);
110 /* Path exists, we don't need to watch parent
113 char *cut2 = oldslash + (oldslash == s->path);
117 inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
118 /* Error is ignored, the worst can happen is
119 we get spurious events. */
131 /* whole path has been iterated over */
138 log_error("Failed to add watch on any of the components of %s: %m",
140 r = -errno; /* either EACCESS or ENOENT */
147 path_spec_unwatch(s);
151 void path_spec_unwatch(PathSpec *s) {
154 s->event_source = sd_event_source_unref(s->event_source);
156 if (s->inotify_fd >= 0) {
157 close_nointr_nofail(s->inotify_fd);
162 int path_spec_fd_event(PathSpec *s, uint32_t revents) {
163 _cleanup_free_ uint8_t *buf = NULL;
164 struct inotify_event *e;
169 if (revents != EPOLLIN) {
170 log_error("Got invalid poll event on inotify.");
174 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
175 log_error("FIONREAD failed: %m");
185 k = read(s->inotify_fd, buf, l);
187 log_error("Failed to read inotify event: %m");
191 e = (struct inotify_event*) buf;
196 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
197 s->primary_wd == e->wd)
200 step = sizeof(struct inotify_event) + e->len;
201 assert(step <= (size_t) k);
203 e = (struct inotify_event*) ((uint8_t*) e + step);
210 static bool path_spec_check_good(PathSpec *s, bool initial) {
216 good = access(s->path, F_OK) >= 0;
219 case PATH_EXISTS_GLOB:
220 good = glob_exists(s->path) > 0;
223 case PATH_DIRECTORY_NOT_EMPTY: {
226 k = dir_is_empty(s->path);
227 good = !(k == -ENOENT || k > 0);
232 case PATH_MODIFIED: {
235 b = access(s->path, F_OK) >= 0;
236 good = !initial && b != s->previous_exists;
237 s->previous_exists = b;
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);
290 LIST_REMOVE(spec, p->specs, s);
296 static void path_done(Unit *u) {
304 static int path_add_mount_links(Path *p) {
310 LIST_FOREACH(spec, s, p->specs) {
311 r = unit_require_mounts_for(UNIT(p), s->path);
319 static int path_verify(Path *p) {
322 if (UNIT(p)->load_state != UNIT_LOADED)
326 log_error_unit(UNIT(p)->id,
327 "%s lacks path setting. Refusing.", UNIT(p)->id);
334 static int path_add_default_dependencies(Path *p) {
339 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
340 SPECIAL_PATHS_TARGET, NULL, true);
344 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
345 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
346 SPECIAL_SYSINIT_TARGET, NULL, true);
351 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
352 SPECIAL_SHUTDOWN_TARGET, NULL, true);
355 static int path_load(Unit *u) {
360 assert(u->load_state == UNIT_STUB);
362 r = unit_load_fragment_and_dropin(u);
366 if (u->load_state == UNIT_LOADED) {
368 if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
371 r = unit_load_related_unit(u, ".service", &x);
375 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
380 r = path_add_mount_links(p);
384 if (UNIT(p)->default_dependencies) {
385 r = path_add_default_dependencies(p);
391 return path_verify(p);
394 static void path_dump(Unit *u, FILE *f, const char *prefix) {
402 trigger = UNIT_TRIGGER(u);
408 "%sMakeDirectory: %s\n"
409 "%sDirectoryMode: %04o\n",
410 prefix, path_state_to_string(p->state),
411 prefix, path_result_to_string(p->result),
412 prefix, trigger ? trigger->id : "n/a",
413 prefix, yes_no(p->make_directory),
414 prefix, p->directory_mode);
416 LIST_FOREACH(spec, s, p->specs)
417 path_spec_dump(s, f, prefix);
420 static void path_unwatch(Path *p) {
425 LIST_FOREACH(spec, s, p->specs)
426 path_spec_unwatch(s);
429 static int path_watch(Path *p) {
435 LIST_FOREACH(spec, s, p->specs) {
436 r = path_spec_watch(s, path_dispatch_io);
444 static void path_set_state(Path *p, PathState state) {
448 old_state = p->state;
451 if (state != PATH_WAITING &&
452 (state != PATH_RUNNING || p->inotify_triggered))
455 if (state != old_state)
456 log_debug("%s changed %s -> %s",
458 path_state_to_string(old_state),
459 path_state_to_string(state));
461 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
464 static void path_enter_waiting(Path *p, bool initial, bool recheck);
466 static int path_coldplug(Unit *u) {
470 assert(p->state == PATH_DEAD);
472 if (p->deserialized_state != p->state) {
474 if (p->deserialized_state == PATH_WAITING ||
475 p->deserialized_state == PATH_RUNNING)
476 path_enter_waiting(p, true, true);
478 path_set_state(p, p->deserialized_state);
484 static void path_enter_dead(Path *p, PathResult f) {
487 if (f != PATH_SUCCESS)
490 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
493 static void path_enter_running(Path *p) {
494 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
499 /* Don't start job if we are supposed to go down */
500 if (unit_stop_pending(UNIT(p)))
503 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_TRIGGER(UNIT(p)),
504 JOB_REPLACE, true, &error, NULL);
508 p->inotify_triggered = false;
514 path_set_state(p, PATH_RUNNING);
518 log_warning("%s failed to queue unit startup job: %s",
519 UNIT(p)->id, bus_error_message(&error, r));
520 path_enter_dead(p, PATH_FAILURE_RESOURCES);
523 static bool path_check_good(Path *p, bool initial) {
529 LIST_FOREACH(spec, s, p->specs) {
530 good = path_spec_check_good(s, initial);
539 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
543 if (path_check_good(p, initial)) {
544 log_debug("%s got triggered.", UNIT(p)->id);
545 path_enter_running(p);
553 /* Hmm, so now we have created inotify watches, but the file
554 * might have appeared/been removed by now, so we must
558 if (path_check_good(p, false)) {
559 log_debug("%s got triggered.", UNIT(p)->id);
560 path_enter_running(p);
564 path_set_state(p, PATH_WAITING);
568 log_warning("%s failed to enter waiting state: %s",
569 UNIT(p)->id, strerror(-r));
570 path_enter_dead(p, PATH_FAILURE_RESOURCES);
573 static void path_mkdir(Path *p) {
578 if (!p->make_directory)
581 LIST_FOREACH(spec, s, p->specs)
582 path_spec_mkdir(s, p->directory_mode);
585 static int path_start(Unit *u) {
589 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
591 if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
596 p->result = PATH_SUCCESS;
597 path_enter_waiting(p, true, true);
602 static int path_stop(Unit *u) {
606 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
608 path_enter_dead(p, PATH_SUCCESS);
612 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
619 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
620 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
625 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
633 if (streq(key, "state")) {
636 state = path_state_from_string(value);
638 log_debug("Failed to parse state value %s", value);
640 p->deserialized_state = state;
642 } else if (streq(key, "result")) {
645 f = path_result_from_string(value);
647 log_debug("Failed to parse result value %s", value);
648 else if (f != PATH_SUCCESS)
652 log_debug("Unknown serialization key '%s'", key);
657 _pure_ static UnitActiveState path_active_state(Unit *u) {
660 return state_translation_table[PATH(u)->state];
663 _pure_ static const char *path_sub_state_to_string(Unit *u) {
666 return path_state_to_string(PATH(u)->state);
669 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
670 PathSpec *s = userdata;
680 if (p->state != PATH_WAITING &&
681 p->state != PATH_RUNNING)
684 /* log_debug("inotify wakeup on %s.", u->id); */
686 LIST_FOREACH(spec, s, p->specs)
687 if (path_spec_owns_inotify_fd(s, fd))
691 log_error("Got event on unknown fd.");
695 changed = path_spec_fd_event(s, revents);
699 /* If we are already running, then remember that one event was
700 * dispatched so that we restart the service only if something
701 * actually changed on disk */
702 p->inotify_triggered = true;
705 path_enter_running(p);
707 path_enter_waiting(p, false, true);
712 path_enter_dead(p, PATH_FAILURE_RESOURCES);
716 static void path_trigger_notify(Unit *u, Unit *other) {
722 /* Invoked whenever the unit we trigger changes state or gains
725 if (other->load_state != UNIT_LOADED)
728 if (p->state == PATH_RUNNING &&
729 UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
730 log_debug_unit(UNIT(p)->id,
731 "%s got notified about unit deactivation.",
734 /* Hmm, so inotify was triggered since the
735 * last activation, so I guess we need to
736 * recheck what is going on. */
737 path_enter_waiting(p, false, p->inotify_triggered);
741 static void path_reset_failed(Unit *u) {
746 if (p->state == PATH_FAILED)
747 path_set_state(p, PATH_DEAD);
749 p->result = PATH_SUCCESS;
752 static const char* const path_state_table[_PATH_STATE_MAX] = {
753 [PATH_DEAD] = "dead",
754 [PATH_WAITING] = "waiting",
755 [PATH_RUNNING] = "running",
756 [PATH_FAILED] = "failed"
759 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
761 static const char* const path_type_table[_PATH_TYPE_MAX] = {
762 [PATH_EXISTS] = "PathExists",
763 [PATH_EXISTS_GLOB] = "PathExistsGlob",
764 [PATH_CHANGED] = "PathChanged",
765 [PATH_MODIFIED] = "PathModified",
766 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
769 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
771 static const char* const path_result_table[_PATH_RESULT_MAX] = {
772 [PATH_SUCCESS] = "success",
773 [PATH_FAILURE_RESOURCES] = "resources"
776 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
778 const UnitVTable path_vtable = {
779 .object_size = sizeof(Path),
790 .coldplug = path_coldplug,
797 .serialize = path_serialize,
798 .deserialize_item = path_deserialize_item,
800 .active_state = path_active_state,
801 .sub_state_to_string = path_sub_state_to_string,
803 .trigger_notify = path_trigger_notify,
805 .reset_failed = path_reset_failed,
807 .bus_interface = "org.freedesktop.systemd1.Path",
808 .bus_vtable = bus_path_vtable,
809 .bus_changing_properties = bus_path_changing_properties