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 "bus-errors.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 _cleanup_free_ *k = NULL;
63 path_spec_unwatch(s, u);
69 s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
70 if (s->inotify_fd < 0) {
75 r = unit_watch_fd(u, s->inotify_fd, EPOLLIN, &s->watch);
79 s->primary_wd = inotify_add_watch(s->inotify_fd, k, flags_table[s->type]);
80 if (s->primary_wd >= 0)
86 /* This assumes the path was passed through path_kill_slashes()! */
87 slash = strrchr(k, '/');
91 /* Trim the path at the last slash. Keep the slash if it's the root dir. */
92 slash[slash == k] = 0;
96 flags |= IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
98 if (inotify_add_watch(s->inotify_fd, k, flags) >= 0)
100 } while (slash != k);
105 path_spec_unwatch(s, u);
109 void path_spec_unwatch(PathSpec *s, Unit *u) {
111 if (s->inotify_fd < 0)
114 unit_unwatch_fd(u, &s->watch);
116 close_nointr_nofail(s->inotify_fd);
120 int path_spec_fd_event(PathSpec *s, uint32_t events) {
121 uint8_t _cleanup_free_ *buf = NULL;
122 struct inotify_event *e;
127 if (events != EPOLLIN) {
128 log_error("Got invalid poll event on inotify.");
132 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
133 log_error("FIONREAD failed: %m");
143 k = read(s->inotify_fd, buf, l);
145 log_error("Failed to read inotify event: %m");
149 e = (struct inotify_event*) buf;
154 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
155 s->primary_wd == e->wd)
158 step = sizeof(struct inotify_event) + e->len;
159 assert(step <= (size_t) k);
161 e = (struct inotify_event*) ((uint8_t*) e + step);
168 static bool path_spec_check_good(PathSpec *s, bool initial) {
174 good = access(s->path, F_OK) >= 0;
177 case PATH_EXISTS_GLOB:
178 good = glob_exists(s->path) > 0;
181 case PATH_DIRECTORY_NOT_EMPTY: {
184 k = dir_is_empty(s->path);
185 good = !(k == -ENOENT || k > 0);
190 case PATH_MODIFIED: {
193 b = access(s->path, F_OK) >= 0;
194 good = !initial && b != s->previous_exists;
195 s->previous_exists = b;
206 static bool path_spec_startswith(PathSpec *s, const char *what) {
207 return path_startswith(s->path, what);
210 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
213 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
216 r = mkdir_p_label(s->path, mode);
218 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
221 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
225 path_type_to_string(s->type),
229 void path_spec_done(PathSpec *s) {
231 assert(s->inotify_fd == -1);
236 static void path_init(Unit *u) {
240 assert(u->load_state == UNIT_STUB);
242 p->directory_mode = 0755;
245 void path_free_specs(Path *p) {
250 while ((s = p->specs)) {
251 path_spec_unwatch(s, UNIT(p));
252 LIST_REMOVE(PathSpec, spec, p->specs, s);
258 static void path_done(Unit *u) {
263 unit_ref_unset(&p->unit);
267 int path_add_one_mount_link(Path *p, Mount *m) {
274 if (UNIT(p)->load_state != UNIT_LOADED ||
275 UNIT(m)->load_state != UNIT_LOADED)
278 LIST_FOREACH(spec, s, p->specs) {
280 if (!path_spec_startswith(s, m->where))
283 if ((r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
290 static int path_add_mount_links(Path *p) {
296 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT])
297 if ((r = path_add_one_mount_link(p, MOUNT(other))) < 0)
303 static int path_verify(Path *p) {
306 if (UNIT(p)->load_state != UNIT_LOADED)
310 log_error_unit(UNIT(p)->id,
311 "%s lacks path setting. Refusing.", UNIT(p)->id);
318 static int path_add_default_dependencies(Path *p) {
323 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
324 if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
327 if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
331 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
334 static int path_load(Unit *u) {
339 assert(u->load_state == UNIT_STUB);
341 if ((r = unit_load_fragment_and_dropin(u)) < 0)
344 if (u->load_state == UNIT_LOADED) {
346 if (!UNIT_DEREF(p->unit)) {
349 r = unit_load_related_unit(u, ".service", &x);
353 unit_ref_set(&p->unit, x);
356 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(p->unit), true);
360 if ((r = path_add_mount_links(p)) < 0)
363 if (UNIT(p)->default_dependencies)
364 if ((r = path_add_default_dependencies(p)) < 0)
368 return path_verify(p);
371 static void path_dump(Unit *u, FILE *f, const char *prefix) {
382 "%sMakeDirectory: %s\n"
383 "%sDirectoryMode: %04o\n",
384 prefix, path_state_to_string(p->state),
385 prefix, path_result_to_string(p->result),
386 prefix, UNIT_DEREF(p->unit)->id,
387 prefix, yes_no(p->make_directory),
388 prefix, p->directory_mode);
390 LIST_FOREACH(spec, s, p->specs)
391 path_spec_dump(s, f, prefix);
394 static void path_unwatch(Path *p) {
399 LIST_FOREACH(spec, s, p->specs)
400 path_spec_unwatch(s, UNIT(p));
403 static int path_watch(Path *p) {
409 LIST_FOREACH(spec, s, p->specs)
410 if ((r = path_spec_watch(s, UNIT(p))) < 0)
416 static void path_set_state(Path *p, PathState state) {
420 old_state = p->state;
423 if (state != PATH_WAITING &&
424 (state != PATH_RUNNING || p->inotify_triggered))
427 if (state != old_state)
428 log_debug("%s changed %s -> %s",
430 path_state_to_string(old_state),
431 path_state_to_string(state));
433 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
436 static void path_enter_waiting(Path *p, bool initial, bool recheck);
438 static int path_coldplug(Unit *u) {
442 assert(p->state == PATH_DEAD);
444 if (p->deserialized_state != p->state) {
446 if (p->deserialized_state == PATH_WAITING ||
447 p->deserialized_state == PATH_RUNNING)
448 path_enter_waiting(p, true, true);
450 path_set_state(p, p->deserialized_state);
456 static void path_enter_dead(Path *p, PathResult f) {
459 if (f != PATH_SUCCESS)
462 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
465 static void path_enter_running(Path *p) {
470 dbus_error_init(&error);
472 /* Don't start job if we are supposed to go down */
473 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
476 if ((r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit), JOB_REPLACE, true, &error, NULL)) < 0)
479 p->inotify_triggered = false;
481 if ((r = path_watch(p)) < 0)
484 path_set_state(p, PATH_RUNNING);
488 log_warning("%s failed to queue unit startup job: %s", UNIT(p)->id, bus_error(&error, r));
489 path_enter_dead(p, PATH_FAILURE_RESOURCES);
491 dbus_error_free(&error);
494 static bool path_check_good(Path *p, bool initial) {
500 LIST_FOREACH(spec, s, p->specs) {
501 good = path_spec_check_good(s, initial);
510 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
514 if (path_check_good(p, initial)) {
515 log_debug("%s got triggered.", UNIT(p)->id);
516 path_enter_running(p);
520 if ((r = path_watch(p)) < 0)
523 /* Hmm, so now we have created inotify watches, but the file
524 * might have appeared/been removed by now, so we must
528 if (path_check_good(p, false)) {
529 log_debug("%s got triggered.", UNIT(p)->id);
530 path_enter_running(p);
534 path_set_state(p, PATH_WAITING);
538 log_warning("%s failed to enter waiting state: %s", UNIT(p)->id, strerror(-r));
539 path_enter_dead(p, PATH_FAILURE_RESOURCES);
542 static void path_mkdir(Path *p) {
547 if (!p->make_directory)
550 LIST_FOREACH(spec, s, p->specs)
551 path_spec_mkdir(s, p->directory_mode);
554 static int path_start(Unit *u) {
558 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
560 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
565 p->result = PATH_SUCCESS;
566 path_enter_waiting(p, true, true);
571 static int path_stop(Unit *u) {
575 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
577 path_enter_dead(p, PATH_SUCCESS);
581 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
588 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
589 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
594 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
602 if (streq(key, "state")) {
605 if ((state = path_state_from_string(value)) < 0)
606 log_debug("Failed to parse state value %s", value);
608 p->deserialized_state = state;
610 } else if (streq(key, "result")) {
613 f = path_result_from_string(value);
615 log_debug("Failed to parse result value %s", value);
616 else if (f != PATH_SUCCESS)
620 log_debug("Unknown serialization key '%s'", key);
625 static UnitActiveState path_active_state(Unit *u) {
628 return state_translation_table[PATH(u)->state];
631 static const char *path_sub_state_to_string(Unit *u) {
634 return path_state_to_string(PATH(u)->state);
637 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
645 if (p->state != PATH_WAITING &&
646 p->state != PATH_RUNNING)
649 /* log_debug("inotify wakeup on %s.", u->id); */
651 LIST_FOREACH(spec, s, p->specs)
652 if (path_spec_owns_inotify_fd(s, fd))
656 log_error("Got event on unknown fd.");
660 changed = path_spec_fd_event(s, events);
664 /* If we are already running, then remember that one event was
665 * dispatched so that we restart the service only if something
666 * actually changed on disk */
667 p->inotify_triggered = true;
670 path_enter_running(p);
672 path_enter_waiting(p, false, true);
677 path_enter_dead(p, PATH_FAILURE_RESOURCES);
680 void path_unit_notify(Unit *u, UnitActiveState new_state) {
684 if (u->type == UNIT_PATH)
687 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
690 if (k->type != UNIT_PATH)
693 if (k->load_state != UNIT_LOADED)
698 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
699 log_debug("%s got notified about unit deactivation.", UNIT(p)->id);
701 /* Hmm, so inotify was triggered since the
702 * last activation, so I guess we need to
703 * recheck what is going on. */
704 path_enter_waiting(p, false, p->inotify_triggered);
709 static void path_reset_failed(Unit *u) {
714 if (p->state == PATH_FAILED)
715 path_set_state(p, PATH_DEAD);
717 p->result = PATH_SUCCESS;
720 static const char* const path_state_table[_PATH_STATE_MAX] = {
721 [PATH_DEAD] = "dead",
722 [PATH_WAITING] = "waiting",
723 [PATH_RUNNING] = "running",
724 [PATH_FAILED] = "failed"
727 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
729 static const char* const path_type_table[_PATH_TYPE_MAX] = {
730 [PATH_EXISTS] = "PathExists",
731 [PATH_EXISTS_GLOB] = "PathExistsGlob",
732 [PATH_CHANGED] = "PathChanged",
733 [PATH_MODIFIED] = "PathModified",
734 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
737 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
739 static const char* const path_result_table[_PATH_RESULT_MAX] = {
740 [PATH_SUCCESS] = "success",
741 [PATH_FAILURE_RESOURCES] = "resources"
744 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
746 const UnitVTable path_vtable = {
747 .object_size = sizeof(Path),
757 .coldplug = path_coldplug,
764 .serialize = path_serialize,
765 .deserialize_item = path_deserialize_item,
767 .active_state = path_active_state,
768 .sub_state_to_string = path_sub_state_to_string,
770 .fd_event = path_fd_event,
772 .reset_failed = path_reset_failed,
774 .bus_interface = "org.freedesktop.systemd1.Path",
775 .bus_message_handler = bus_path_message_handler,
776 .bus_invalidating_properties = bus_path_invalidating_properties