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) {
122 struct inotify_event *e;
127 if (events != EPOLLIN) {
128 log_error("Got invalid poll event on inotify.");
133 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
134 log_error("FIONREAD failed: %m");
143 log_error("Failed to allocate buffer: %m");
148 k = read(s->inotify_fd, buf, l);
150 log_error("Failed to read inotify event: %m");
155 e = (struct inotify_event*) buf;
160 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
161 s->primary_wd == e->wd)
164 step = sizeof(struct inotify_event) + e->len;
165 assert(step <= (size_t) k);
167 e = (struct inotify_event*) ((uint8_t*) e + step);
175 static bool path_spec_check_good(PathSpec *s, bool initial) {
181 good = access(s->path, F_OK) >= 0;
184 case PATH_EXISTS_GLOB:
185 good = glob_exists(s->path) > 0;
188 case PATH_DIRECTORY_NOT_EMPTY: {
191 k = dir_is_empty(s->path);
192 good = !(k == -ENOENT || k > 0);
197 case PATH_MODIFIED: {
200 b = access(s->path, F_OK) >= 0;
201 good = !initial && b != s->previous_exists;
202 s->previous_exists = b;
213 static bool path_spec_startswith(PathSpec *s, const char *what) {
214 return path_startswith(s->path, what);
217 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
220 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
223 r = mkdir_p_label(s->path, mode);
225 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
228 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
232 path_type_to_string(s->type),
236 void path_spec_done(PathSpec *s) {
238 assert(s->inotify_fd == -1);
243 static void path_init(Unit *u) {
247 assert(u->load_state == UNIT_STUB);
249 p->directory_mode = 0755;
252 void path_free_specs(Path *p) {
257 while ((s = p->specs)) {
258 path_spec_unwatch(s, UNIT(p));
259 LIST_REMOVE(PathSpec, spec, p->specs, s);
265 static void path_done(Unit *u) {
270 unit_ref_unset(&p->unit);
274 int path_add_one_mount_link(Path *p, Mount *m) {
281 if (UNIT(p)->load_state != UNIT_LOADED ||
282 UNIT(m)->load_state != UNIT_LOADED)
285 LIST_FOREACH(spec, s, p->specs) {
287 if (!path_spec_startswith(s, m->where))
290 if ((r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
297 static int path_add_mount_links(Path *p) {
303 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT])
304 if ((r = path_add_one_mount_link(p, MOUNT(other))) < 0)
310 static int path_verify(Path *p) {
313 if (UNIT(p)->load_state != UNIT_LOADED)
317 log_error_unit(UNIT(p)->id,
318 "%s lacks path setting. Refusing.", UNIT(p)->id);
325 static int path_add_default_dependencies(Path *p) {
330 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
331 if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
334 if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
338 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
341 static int path_load(Unit *u) {
346 assert(u->load_state == UNIT_STUB);
348 if ((r = unit_load_fragment_and_dropin(u)) < 0)
351 if (u->load_state == UNIT_LOADED) {
353 if (!UNIT_DEREF(p->unit)) {
356 r = unit_load_related_unit(u, ".service", &x);
360 unit_ref_set(&p->unit, x);
363 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(p->unit), true);
367 if ((r = path_add_mount_links(p)) < 0)
370 if (UNIT(p)->default_dependencies)
371 if ((r = path_add_default_dependencies(p)) < 0)
375 return path_verify(p);
378 static void path_dump(Unit *u, FILE *f, const char *prefix) {
389 "%sMakeDirectory: %s\n"
390 "%sDirectoryMode: %04o\n",
391 prefix, path_state_to_string(p->state),
392 prefix, path_result_to_string(p->result),
393 prefix, UNIT_DEREF(p->unit)->id,
394 prefix, yes_no(p->make_directory),
395 prefix, p->directory_mode);
397 LIST_FOREACH(spec, s, p->specs)
398 path_spec_dump(s, f, prefix);
401 static void path_unwatch(Path *p) {
406 LIST_FOREACH(spec, s, p->specs)
407 path_spec_unwatch(s, UNIT(p));
410 static int path_watch(Path *p) {
416 LIST_FOREACH(spec, s, p->specs)
417 if ((r = path_spec_watch(s, UNIT(p))) < 0)
423 static void path_set_state(Path *p, PathState state) {
427 old_state = p->state;
430 if (state != PATH_WAITING &&
431 (state != PATH_RUNNING || p->inotify_triggered))
434 if (state != old_state)
435 log_debug("%s changed %s -> %s",
437 path_state_to_string(old_state),
438 path_state_to_string(state));
440 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
443 static void path_enter_waiting(Path *p, bool initial, bool recheck);
445 static int path_coldplug(Unit *u) {
449 assert(p->state == PATH_DEAD);
451 if (p->deserialized_state != p->state) {
453 if (p->deserialized_state == PATH_WAITING ||
454 p->deserialized_state == PATH_RUNNING)
455 path_enter_waiting(p, true, true);
457 path_set_state(p, p->deserialized_state);
463 static void path_enter_dead(Path *p, PathResult f) {
466 if (f != PATH_SUCCESS)
469 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
472 static void path_enter_running(Path *p) {
477 dbus_error_init(&error);
479 /* Don't start job if we are supposed to go down */
480 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
483 if ((r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit), JOB_REPLACE, true, &error, NULL)) < 0)
486 p->inotify_triggered = false;
488 if ((r = path_watch(p)) < 0)
491 path_set_state(p, PATH_RUNNING);
495 log_warning("%s failed to queue unit startup job: %s", UNIT(p)->id, bus_error(&error, r));
496 path_enter_dead(p, PATH_FAILURE_RESOURCES);
498 dbus_error_free(&error);
501 static bool path_check_good(Path *p, bool initial) {
507 LIST_FOREACH(spec, s, p->specs) {
508 good = path_spec_check_good(s, initial);
517 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
521 if (path_check_good(p, initial)) {
522 log_debug("%s got triggered.", UNIT(p)->id);
523 path_enter_running(p);
527 if ((r = path_watch(p)) < 0)
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("%s failed to enter waiting state: %s", UNIT(p)->id, strerror(-r));
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_DEREF(p->unit)->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 if ((state = path_state_from_string(value)) < 0)
613 log_debug("Failed to parse state value %s", value);
615 p->deserialized_state = state;
617 } else if (streq(key, "result")) {
620 f = path_result_from_string(value);
622 log_debug("Failed to parse result value %s", value);
623 else if (f != PATH_SUCCESS)
627 log_debug("Unknown serialization key '%s'", key);
632 static UnitActiveState path_active_state(Unit *u) {
635 return state_translation_table[PATH(u)->state];
638 static const char *path_sub_state_to_string(Unit *u) {
641 return path_state_to_string(PATH(u)->state);
644 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
652 if (p->state != PATH_WAITING &&
653 p->state != PATH_RUNNING)
656 /* log_debug("inotify wakeup on %s.", u->id); */
658 LIST_FOREACH(spec, s, p->specs)
659 if (path_spec_owns_inotify_fd(s, fd))
663 log_error("Got event on unknown fd.");
667 changed = path_spec_fd_event(s, events);
671 /* If we are already running, then remember that one event was
672 * dispatched so that we restart the service only if something
673 * actually changed on disk */
674 p->inotify_triggered = true;
677 path_enter_running(p);
679 path_enter_waiting(p, false, true);
684 path_enter_dead(p, PATH_FAILURE_RESOURCES);
687 void path_unit_notify(Unit *u, UnitActiveState new_state) {
691 if (u->type == UNIT_PATH)
694 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
697 if (k->type != UNIT_PATH)
700 if (k->load_state != UNIT_LOADED)
705 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
706 log_debug("%s got notified about unit deactivation.", UNIT(p)->id);
708 /* Hmm, so inotify was triggered since the
709 * last activation, so I guess we need to
710 * recheck what is going on. */
711 path_enter_waiting(p, false, p->inotify_triggered);
716 static void path_reset_failed(Unit *u) {
721 if (p->state == PATH_FAILED)
722 path_set_state(p, PATH_DEAD);
724 p->result = PATH_SUCCESS;
727 static const char* const path_state_table[_PATH_STATE_MAX] = {
728 [PATH_DEAD] = "dead",
729 [PATH_WAITING] = "waiting",
730 [PATH_RUNNING] = "running",
731 [PATH_FAILED] = "failed"
734 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
736 static const char* const path_type_table[_PATH_TYPE_MAX] = {
737 [PATH_EXISTS] = "PathExists",
738 [PATH_EXISTS_GLOB] = "PathExistsGlob",
739 [PATH_CHANGED] = "PathChanged",
740 [PATH_MODIFIED] = "PathModified",
741 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
744 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
746 static const char* const path_result_table[_PATH_RESULT_MAX] = {
747 [PATH_SUCCESS] = "success",
748 [PATH_FAILURE_RESOURCES] = "resources"
751 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
753 const UnitVTable path_vtable = {
754 .object_size = sizeof(Path),
764 .coldplug = path_coldplug,
771 .serialize = path_serialize,
772 .deserialize_item = path_deserialize_item,
774 .active_state = path_active_state,
775 .sub_state_to_string = path_sub_state_to_string,
777 .fd_event = path_fd_event,
779 .reset_failed = path_reset_failed,
781 .bus_interface = "org.freedesktop.systemd1.Path",
782 .bus_message_handler = bus_path_message_handler,
783 .bus_invalidating_properties = bus_path_invalidating_properties