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) {
279 if (!path_spec_startswith(s, m->where))
282 r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
291 static int path_add_mount_links(Path *p) {
297 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT]) {
298 r = path_add_one_mount_link(p, MOUNT(other));
306 static int path_verify(Path *p) {
309 if (UNIT(p)->load_state != UNIT_LOADED)
313 log_error_unit(UNIT(p)->id,
314 "%s lacks path setting. Refusing.", UNIT(p)->id);
321 static int path_add_default_dependencies(Path *p) {
326 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
327 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE,
328 SPECIAL_BASIC_TARGET, NULL, true);
332 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES,
333 SPECIAL_SYSINIT_TARGET, NULL, true);
338 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS,
339 SPECIAL_SHUTDOWN_TARGET, NULL, true);
342 static int path_load(Unit *u) {
347 assert(u->load_state == UNIT_STUB);
349 r = unit_load_fragment_and_dropin(u);
353 if (u->load_state == UNIT_LOADED) {
355 if (!UNIT_DEREF(p->unit)) {
358 r = unit_load_related_unit(u, ".service", &x);
362 unit_ref_set(&p->unit, x);
365 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS,
366 UNIT_DEREF(p->unit), true);
370 r = path_add_mount_links(p);
374 if (UNIT(p)->default_dependencies) {
375 r = path_add_default_dependencies(p);
381 return path_verify(p);
384 static void path_dump(Unit *u, FILE *f, const char *prefix) {
395 "%sMakeDirectory: %s\n"
396 "%sDirectoryMode: %04o\n",
397 prefix, path_state_to_string(p->state),
398 prefix, path_result_to_string(p->result),
399 prefix, UNIT_DEREF(p->unit)->id,
400 prefix, yes_no(p->make_directory),
401 prefix, p->directory_mode);
403 LIST_FOREACH(spec, s, p->specs)
404 path_spec_dump(s, f, prefix);
407 static void path_unwatch(Path *p) {
412 LIST_FOREACH(spec, s, p->specs)
413 path_spec_unwatch(s, UNIT(p));
416 static int path_watch(Path *p) {
422 LIST_FOREACH(spec, s, p->specs) {
423 r = path_spec_watch(s, UNIT(p));
431 static void path_set_state(Path *p, PathState state) {
435 old_state = p->state;
438 if (state != PATH_WAITING &&
439 (state != PATH_RUNNING || p->inotify_triggered))
442 if (state != old_state)
443 log_debug("%s changed %s -> %s",
445 path_state_to_string(old_state),
446 path_state_to_string(state));
448 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
451 static void path_enter_waiting(Path *p, bool initial, bool recheck);
453 static int path_coldplug(Unit *u) {
457 assert(p->state == PATH_DEAD);
459 if (p->deserialized_state != p->state) {
461 if (p->deserialized_state == PATH_WAITING ||
462 p->deserialized_state == PATH_RUNNING)
463 path_enter_waiting(p, true, true);
465 path_set_state(p, p->deserialized_state);
471 static void path_enter_dead(Path *p, PathResult f) {
474 if (f != PATH_SUCCESS)
477 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
480 static void path_enter_running(Path *p) {
485 dbus_error_init(&error);
487 /* Don't start job if we are supposed to go down */
488 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
491 r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit),
492 JOB_REPLACE, true, &error, NULL);
496 p->inotify_triggered = false;
502 path_set_state(p, PATH_RUNNING);
506 log_warning("%s failed to queue unit startup job: %s",
507 UNIT(p)->id, bus_error(&error, r));
508 path_enter_dead(p, PATH_FAILURE_RESOURCES);
510 dbus_error_free(&error);
513 static bool path_check_good(Path *p, bool initial) {
519 LIST_FOREACH(spec, s, p->specs) {
520 good = path_spec_check_good(s, initial);
529 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
533 if (path_check_good(p, initial)) {
534 log_debug("%s got triggered.", UNIT(p)->id);
535 path_enter_running(p);
543 /* Hmm, so now we have created inotify watches, but the file
544 * might have appeared/been removed by now, so we must
548 if (path_check_good(p, false)) {
549 log_debug("%s got triggered.", UNIT(p)->id);
550 path_enter_running(p);
554 path_set_state(p, PATH_WAITING);
558 log_warning("%s failed to enter waiting state: %s",
559 UNIT(p)->id, strerror(-r));
560 path_enter_dead(p, PATH_FAILURE_RESOURCES);
563 static void path_mkdir(Path *p) {
568 if (!p->make_directory)
571 LIST_FOREACH(spec, s, p->specs)
572 path_spec_mkdir(s, p->directory_mode);
575 static int path_start(Unit *u) {
579 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
581 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
586 p->result = PATH_SUCCESS;
587 path_enter_waiting(p, true, true);
592 static int path_stop(Unit *u) {
596 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
598 path_enter_dead(p, PATH_SUCCESS);
602 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
609 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
610 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
615 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
623 if (streq(key, "state")) {
626 state = path_state_from_string(value);
628 log_debug("Failed to parse state value %s", value);
630 p->deserialized_state = state;
632 } else if (streq(key, "result")) {
635 f = path_result_from_string(value);
637 log_debug("Failed to parse result value %s", value);
638 else if (f != PATH_SUCCESS)
642 log_debug("Unknown serialization key '%s'", key);
647 static UnitActiveState path_active_state(Unit *u) {
650 return state_translation_table[PATH(u)->state];
653 static const char *path_sub_state_to_string(Unit *u) {
656 return path_state_to_string(PATH(u)->state);
659 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
667 if (p->state != PATH_WAITING &&
668 p->state != PATH_RUNNING)
671 /* log_debug("inotify wakeup on %s.", u->id); */
673 LIST_FOREACH(spec, s, p->specs)
674 if (path_spec_owns_inotify_fd(s, fd))
678 log_error("Got event on unknown fd.");
682 changed = path_spec_fd_event(s, events);
686 /* If we are already running, then remember that one event was
687 * dispatched so that we restart the service only if something
688 * actually changed on disk */
689 p->inotify_triggered = true;
692 path_enter_running(p);
694 path_enter_waiting(p, false, true);
699 path_enter_dead(p, PATH_FAILURE_RESOURCES);
702 void path_unit_notify(Unit *u, UnitActiveState new_state) {
706 if (u->type == UNIT_PATH)
709 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
712 if (k->type != UNIT_PATH)
715 if (k->load_state != UNIT_LOADED)
720 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
721 log_debug("%s got notified about unit deactivation.",
724 /* Hmm, so inotify was triggered since the
725 * last activation, so I guess we need to
726 * recheck what is going on. */
727 path_enter_waiting(p, false, p->inotify_triggered);
732 static void path_reset_failed(Unit *u) {
737 if (p->state == PATH_FAILED)
738 path_set_state(p, PATH_DEAD);
740 p->result = PATH_SUCCESS;
743 static const char* const path_state_table[_PATH_STATE_MAX] = {
744 [PATH_DEAD] = "dead",
745 [PATH_WAITING] = "waiting",
746 [PATH_RUNNING] = "running",
747 [PATH_FAILED] = "failed"
750 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
752 static const char* const path_type_table[_PATH_TYPE_MAX] = {
753 [PATH_EXISTS] = "PathExists",
754 [PATH_EXISTS_GLOB] = "PathExistsGlob",
755 [PATH_CHANGED] = "PathChanged",
756 [PATH_MODIFIED] = "PathModified",
757 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
760 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
762 static const char* const path_result_table[_PATH_RESULT_MAX] = {
763 [PATH_SUCCESS] = "success",
764 [PATH_FAILURE_RESOURCES] = "resources"
767 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
769 const UnitVTable path_vtable = {
770 .object_size = sizeof(Path),
780 .coldplug = path_coldplug,
787 .serialize = path_serialize,
788 .deserialize_item = path_deserialize_item,
790 .active_state = path_active_state,
791 .sub_state_to_string = path_sub_state_to_string,
793 .fd_event = path_fd_event,
795 .reset_failed = path_reset_failed,
797 .bus_interface = "org.freedesktop.systemd1.Path",
798 .bus_message_handler = bus_path_message_handler,
799 .bus_invalidating_properties = bus_path_invalidating_properties