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_errno(errno, "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 union inotify_event_buffer buffer;
161 struct inotify_event *e;
165 if (revents != EPOLLIN) {
166 log_error("Got invalid poll event on inotify.");
170 l = read(s->inotify_fd, &buffer, sizeof(buffer));
172 if (errno == EAGAIN || errno == EINTR)
175 return log_error_errno(errno, "Failed to read inotify event: %m");
178 FOREACH_INOTIFY_EVENT(e, buffer, l) {
179 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
180 s->primary_wd == e->wd)
187 static bool path_spec_check_good(PathSpec *s, bool initial) {
193 good = access(s->path, F_OK) >= 0;
196 case PATH_EXISTS_GLOB:
197 good = glob_exists(s->path) > 0;
200 case PATH_DIRECTORY_NOT_EMPTY: {
203 k = dir_is_empty(s->path);
204 good = !(k == -ENOENT || k > 0);
209 case PATH_MODIFIED: {
212 b = access(s->path, F_OK) >= 0;
213 good = !initial && b != s->previous_exists;
214 s->previous_exists = b;
225 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
228 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
231 r = mkdir_p_label(s->path, mode);
233 log_warning_errno(r, "mkdir(%s) failed: %m", s->path);
236 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
240 path_type_to_string(s->type),
244 void path_spec_done(PathSpec *s) {
246 assert(s->inotify_fd == -1);
251 static void path_init(Unit *u) {
255 assert(u->load_state == UNIT_STUB);
257 p->directory_mode = 0755;
260 void path_free_specs(Path *p) {
265 while ((s = p->specs)) {
266 path_spec_unwatch(s);
267 LIST_REMOVE(spec, p->specs, s);
273 static void path_done(Unit *u) {
281 static int path_add_mount_links(Path *p) {
287 LIST_FOREACH(spec, s, p->specs) {
288 r = unit_require_mounts_for(UNIT(p), s->path);
296 static int path_verify(Path *p) {
299 if (UNIT(p)->load_state != UNIT_LOADED)
303 log_unit_error(UNIT(p)->id,
304 "%s lacks path setting. Refusing.", UNIT(p)->id);
311 static int path_add_default_dependencies(Path *p) {
316 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
317 SPECIAL_PATHS_TARGET, NULL, true);
321 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
322 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
323 SPECIAL_SYSINIT_TARGET, NULL, true);
328 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
329 SPECIAL_SHUTDOWN_TARGET, NULL, true);
332 static int path_load(Unit *u) {
337 assert(u->load_state == UNIT_STUB);
339 r = unit_load_fragment_and_dropin(u);
343 if (u->load_state == UNIT_LOADED) {
345 if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
348 r = unit_load_related_unit(u, ".service", &x);
352 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
357 r = path_add_mount_links(p);
361 if (UNIT(p)->default_dependencies) {
362 r = path_add_default_dependencies(p);
368 return path_verify(p);
371 static void path_dump(Unit *u, FILE *f, const char *prefix) {
379 trigger = UNIT_TRIGGER(u);
385 "%sMakeDirectory: %s\n"
386 "%sDirectoryMode: %04o\n",
387 prefix, path_state_to_string(p->state),
388 prefix, path_result_to_string(p->result),
389 prefix, trigger ? trigger->id : "n/a",
390 prefix, yes_no(p->make_directory),
391 prefix, p->directory_mode);
393 LIST_FOREACH(spec, s, p->specs)
394 path_spec_dump(s, f, prefix);
397 static void path_unwatch(Path *p) {
402 LIST_FOREACH(spec, s, p->specs)
403 path_spec_unwatch(s);
406 static int path_watch(Path *p) {
412 LIST_FOREACH(spec, s, p->specs) {
413 r = path_spec_watch(s, path_dispatch_io);
421 static void path_set_state(Path *p, PathState state) {
425 old_state = p->state;
428 if (state != PATH_WAITING &&
429 (state != PATH_RUNNING || p->inotify_triggered))
432 if (state != old_state)
433 log_debug("%s changed %s -> %s",
435 path_state_to_string(old_state),
436 path_state_to_string(state));
438 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
441 static void path_enter_waiting(Path *p, bool initial, bool recheck);
443 static int path_coldplug(Unit *u) {
447 assert(p->state == PATH_DEAD);
449 if (p->deserialized_state != p->state) {
451 if (p->deserialized_state == PATH_WAITING ||
452 p->deserialized_state == PATH_RUNNING)
453 path_enter_waiting(p, true, true);
455 path_set_state(p, p->deserialized_state);
461 static void path_enter_dead(Path *p, PathResult f) {
464 if (f != PATH_SUCCESS)
467 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
470 static void path_enter_running(Path *p) {
471 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
476 /* Don't start job if we are supposed to go down */
477 if (unit_stop_pending(UNIT(p)))
480 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_TRIGGER(UNIT(p)),
481 JOB_REPLACE, true, &error, NULL);
485 p->inotify_triggered = false;
491 path_set_state(p, PATH_RUNNING);
495 log_warning("%s failed to queue unit startup job: %s",
496 UNIT(p)->id, bus_error_message(&error, r));
497 path_enter_dead(p, PATH_FAILURE_RESOURCES);
500 static bool path_check_good(Path *p, bool initial) {
506 LIST_FOREACH(spec, s, p->specs) {
507 good = path_spec_check_good(s, initial);
516 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
520 if (path_check_good(p, initial)) {
521 log_debug("%s got triggered.", UNIT(p)->id);
522 path_enter_running(p);
530 /* Hmm, so now we have created inotify watches, but the file
531 * might have appeared/been removed by now, so we must
535 if (path_check_good(p, false)) {
536 log_debug("%s got triggered.", UNIT(p)->id);
537 path_enter_running(p);
541 path_set_state(p, PATH_WAITING);
545 log_warning_errno(r, "%s failed to enter waiting state: %m", UNIT(p)->id);
546 path_enter_dead(p, PATH_FAILURE_RESOURCES);
549 static void path_mkdir(Path *p) {
554 if (!p->make_directory)
557 LIST_FOREACH(spec, s, p->specs)
558 path_spec_mkdir(s, p->directory_mode);
561 static int path_start(Unit *u) {
565 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
567 if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
572 p->result = PATH_SUCCESS;
573 path_enter_waiting(p, true, true);
578 static int path_stop(Unit *u) {
582 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
584 path_enter_dead(p, PATH_SUCCESS);
588 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
595 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
596 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
601 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
609 if (streq(key, "state")) {
612 state = path_state_from_string(value);
614 log_debug("Failed to parse state value %s", value);
616 p->deserialized_state = state;
618 } else if (streq(key, "result")) {
621 f = path_result_from_string(value);
623 log_debug("Failed to parse result value %s", value);
624 else if (f != PATH_SUCCESS)
628 log_debug("Unknown serialization key '%s'", key);
633 _pure_ static UnitActiveState path_active_state(Unit *u) {
636 return state_translation_table[PATH(u)->state];
639 _pure_ static const char *path_sub_state_to_string(Unit *u) {
642 return path_state_to_string(PATH(u)->state);
645 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
646 PathSpec *s = userdata;
656 if (p->state != PATH_WAITING &&
657 p->state != PATH_RUNNING)
660 /* log_debug("inotify wakeup on %s.", u->id); */
662 LIST_FOREACH(spec, s, p->specs)
663 if (path_spec_owns_inotify_fd(s, fd))
667 log_error("Got event on unknown fd.");
671 changed = path_spec_fd_event(s, revents);
675 /* If we are already running, then remember that one event was
676 * dispatched so that we restart the service only if something
677 * actually changed on disk */
678 p->inotify_triggered = true;
681 path_enter_running(p);
683 path_enter_waiting(p, false, true);
688 path_enter_dead(p, PATH_FAILURE_RESOURCES);
692 static void path_trigger_notify(Unit *u, Unit *other) {
698 /* Invoked whenever the unit we trigger changes state or gains
701 if (other->load_state != UNIT_LOADED)
704 if (p->state == PATH_RUNNING &&
705 UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
706 log_unit_debug(UNIT(p)->id,
707 "%s got notified about unit deactivation.",
710 /* Hmm, so inotify was triggered since the
711 * last activation, so I guess we need to
712 * recheck what is going on. */
713 path_enter_waiting(p, false, p->inotify_triggered);
717 static void path_reset_failed(Unit *u) {
722 if (p->state == PATH_FAILED)
723 path_set_state(p, PATH_DEAD);
725 p->result = PATH_SUCCESS;
728 static const char* const path_state_table[_PATH_STATE_MAX] = {
729 [PATH_DEAD] = "dead",
730 [PATH_WAITING] = "waiting",
731 [PATH_RUNNING] = "running",
732 [PATH_FAILED] = "failed"
735 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
737 static const char* const path_type_table[_PATH_TYPE_MAX] = {
738 [PATH_EXISTS] = "PathExists",
739 [PATH_EXISTS_GLOB] = "PathExistsGlob",
740 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
741 [PATH_CHANGED] = "PathChanged",
742 [PATH_MODIFIED] = "PathModified",
745 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
747 static const char* const path_result_table[_PATH_RESULT_MAX] = {
748 [PATH_SUCCESS] = "success",
749 [PATH_FAILURE_RESOURCES] = "resources",
752 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
754 const UnitVTable path_vtable = {
755 .object_size = sizeof(Path),
766 .coldplug = path_coldplug,
773 .serialize = path_serialize,
774 .deserialize_item = path_deserialize_item,
776 .active_state = path_active_state,
777 .sub_state_to_string = path_sub_state_to_string,
779 .trigger_notify = path_trigger_notify,
781 .reset_failed = path_reset_failed,
783 .bus_interface = "org.freedesktop.systemd1.Path",
784 .bus_vtable = bus_path_vtable