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"
36 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
37 [PATH_DEAD] = UNIT_INACTIVE,
38 [PATH_WAITING] = UNIT_ACTIVE,
39 [PATH_RUNNING] = UNIT_ACTIVE,
40 [PATH_FAILED] = UNIT_FAILED
43 int path_spec_watch(PathSpec *s, Unit *u) {
45 static const int flags_table[_PATH_TYPE_MAX] = {
46 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
47 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
48 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
49 [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,
50 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
60 path_spec_unwatch(s, u);
62 if (!(k = strdup(s->path)))
65 if ((s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC)) < 0) {
70 if (unit_watch_fd(u, s->inotify_fd, EPOLLIN, &s->watch) < 0) {
75 if ((s->primary_wd = inotify_add_watch(s->inotify_fd, k, flags_table[s->type])) >= 0)
81 /* This assumes the path was passed through path_kill_slashes()! */
82 if (!(slash = strrchr(k, '/')))
85 /* Trim the path at the last slash. Keep the slash if it's the root dir. */
86 slash[slash == k] = 0;
90 flags |= IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
92 if (inotify_add_watch(s->inotify_fd, k, flags) >= 0)
101 path_spec_unwatch(s, u);
105 void path_spec_unwatch(PathSpec *s, Unit *u) {
107 if (s->inotify_fd < 0)
110 unit_unwatch_fd(u, &s->watch);
112 close_nointr_nofail(s->inotify_fd);
116 int path_spec_fd_event(PathSpec *s, uint32_t events) {
118 struct inotify_event *e;
123 if (events != EPOLLIN) {
124 log_error("Got Invalid poll event on inotify.");
129 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
130 log_error("FIONREAD failed: %m");
137 if (!(buf = malloc(l))) {
138 log_error("Failed to allocate buffer: %m");
143 if ((k = read(s->inotify_fd, buf, l)) < 0) {
144 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);
169 static bool path_spec_check_good(PathSpec *s, bool initial) {
175 good = access(s->path, F_OK) >= 0;
178 case PATH_EXISTS_GLOB:
179 good = glob_exists(s->path) > 0;
182 case PATH_DIRECTORY_NOT_EMPTY: {
185 k = dir_is_empty(s->path);
186 good = !(k == -ENOENT || k > 0);
191 case PATH_MODIFIED: {
194 b = access(s->path, F_OK) >= 0;
195 good = !initial && b != s->previous_exists;
196 s->previous_exists = b;
207 static bool path_spec_startswith(PathSpec *s, const char *what) {
208 return path_startswith(s->path, what);
211 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
214 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
217 if ((r = mkdir_p(s->path, mode)) < 0)
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 static void path_done(Unit *u) {
251 unit_ref_unset(&p->unit);
253 while ((s = p->specs)) {
254 path_spec_unwatch(s, u);
255 LIST_REMOVE(PathSpec, spec, p->specs, s);
261 int path_add_one_mount_link(Path *p, Mount *m) {
268 if (UNIT(p)->load_state != UNIT_LOADED ||
269 UNIT(m)->load_state != UNIT_LOADED)
272 LIST_FOREACH(spec, s, p->specs) {
274 if (!path_spec_startswith(s, m->where))
277 if ((r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
284 static int path_add_mount_links(Path *p) {
290 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT])
291 if ((r = path_add_one_mount_link(p, MOUNT(other))) < 0)
297 static int path_verify(Path *p) {
300 if (UNIT(p)->load_state != UNIT_LOADED)
304 log_error("%s lacks path setting. Refusing.", UNIT(p)->id);
311 static int path_add_default_dependencies(Path *p) {
316 if (UNIT(p)->manager->running_as == MANAGER_SYSTEM) {
317 if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
320 if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
324 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
327 static int path_load(Unit *u) {
332 assert(u->load_state == UNIT_STUB);
334 if ((r = unit_load_fragment_and_dropin(u)) < 0)
337 if (u->load_state == UNIT_LOADED) {
339 if (!UNIT_DEREF(p->unit)) {
342 r = unit_load_related_unit(u, ".service", &x);
346 unit_ref_set(&p->unit, x);
349 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(p->unit), true);
353 if ((r = path_add_mount_links(p)) < 0)
356 if (UNIT(p)->default_dependencies)
357 if ((r = path_add_default_dependencies(p)) < 0)
361 return path_verify(p);
364 static void path_dump(Unit *u, FILE *f, const char *prefix) {
375 "%sMakeDirectory: %s\n"
376 "%sDirectoryMode: %04o\n",
377 prefix, path_state_to_string(p->state),
378 prefix, path_result_to_string(p->result),
379 prefix, UNIT_DEREF(p->unit)->id,
380 prefix, yes_no(p->make_directory),
381 prefix, p->directory_mode);
383 LIST_FOREACH(spec, s, p->specs)
384 path_spec_dump(s, f, prefix);
387 static void path_unwatch(Path *p) {
392 LIST_FOREACH(spec, s, p->specs)
393 path_spec_unwatch(s, UNIT(p));
396 static int path_watch(Path *p) {
402 LIST_FOREACH(spec, s, p->specs)
403 if ((r = path_spec_watch(s, UNIT(p))) < 0)
409 static void path_set_state(Path *p, PathState state) {
413 old_state = p->state;
416 if (state != PATH_WAITING &&
417 (state != PATH_RUNNING || p->inotify_triggered))
420 if (state != old_state)
421 log_debug("%s changed %s -> %s",
423 path_state_to_string(old_state),
424 path_state_to_string(state));
426 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
429 static void path_enter_waiting(Path *p, bool initial, bool recheck);
431 static int path_coldplug(Unit *u) {
435 assert(p->state == PATH_DEAD);
437 if (p->deserialized_state != p->state) {
439 if (p->deserialized_state == PATH_WAITING ||
440 p->deserialized_state == PATH_RUNNING)
441 path_enter_waiting(p, true, true);
443 path_set_state(p, p->deserialized_state);
449 static void path_enter_dead(Path *p, PathResult f) {
452 if (f != PATH_SUCCESS)
455 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
458 static void path_enter_running(Path *p) {
463 dbus_error_init(&error);
465 /* Don't start job if we are supposed to go down */
466 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
469 if ((r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit), JOB_REPLACE, true, &error, NULL)) < 0)
472 p->inotify_triggered = false;
474 if ((r = path_watch(p)) < 0)
477 path_set_state(p, PATH_RUNNING);
481 log_warning("%s failed to queue unit startup job: %s", UNIT(p)->id, bus_error(&error, r));
482 path_enter_dead(p, PATH_FAILURE_RESOURCES);
484 dbus_error_free(&error);
487 static bool path_check_good(Path *p, bool initial) {
493 LIST_FOREACH(spec, s, p->specs) {
494 good = path_spec_check_good(s, initial);
503 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
507 if (path_check_good(p, initial)) {
508 log_debug("%s got triggered.", UNIT(p)->id);
509 path_enter_running(p);
513 if ((r = path_watch(p)) < 0)
516 /* Hmm, so now we have created inotify watches, but the file
517 * might have appeared/been removed by now, so we must
521 if (path_check_good(p, false)) {
522 log_debug("%s got triggered.", UNIT(p)->id);
523 path_enter_running(p);
527 path_set_state(p, PATH_WAITING);
531 log_warning("%s failed to enter waiting state: %s", UNIT(p)->id, strerror(-r));
532 path_enter_dead(p, PATH_FAILURE_RESOURCES);
535 static void path_mkdir(Path *p) {
540 if (!p->make_directory)
543 LIST_FOREACH(spec, s, p->specs)
544 path_spec_mkdir(s, p->directory_mode);
547 static int path_start(Unit *u) {
551 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
553 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
558 p->result = PATH_SUCCESS;
559 path_enter_waiting(p, true, true);
564 static int path_stop(Unit *u) {
568 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
570 path_enter_dead(p, PATH_SUCCESS);
574 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
581 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
582 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
587 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
595 if (streq(key, "state")) {
598 if ((state = path_state_from_string(value)) < 0)
599 log_debug("Failed to parse state value %s", value);
601 p->deserialized_state = state;
603 } else if (streq(key, "result")) {
606 f = path_result_from_string(value);
608 log_debug("Failed to parse result value %s", value);
609 else if (f != PATH_SUCCESS)
613 log_debug("Unknown serialization key '%s'", key);
618 static UnitActiveState path_active_state(Unit *u) {
621 return state_translation_table[PATH(u)->state];
624 static const char *path_sub_state_to_string(Unit *u) {
627 return path_state_to_string(PATH(u)->state);
630 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
638 if (p->state != PATH_WAITING &&
639 p->state != PATH_RUNNING)
642 /* log_debug("inotify wakeup on %s.", u->id); */
644 LIST_FOREACH(spec, s, p->specs)
645 if (path_spec_owns_inotify_fd(s, fd))
649 log_error("Got event on unknown fd.");
653 changed = path_spec_fd_event(s, events);
657 /* If we are already running, then remember that one event was
658 * dispatched so that we restart the service only if something
659 * actually changed on disk */
660 p->inotify_triggered = true;
663 path_enter_running(p);
665 path_enter_waiting(p, false, true);
670 path_enter_dead(p, PATH_FAILURE_RESOURCES);
673 void path_unit_notify(Unit *u, UnitActiveState new_state) {
677 if (u->type == UNIT_PATH)
680 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
683 if (k->type != UNIT_PATH)
686 if (k->load_state != UNIT_LOADED)
691 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
692 log_debug("%s got notified about unit deactivation.", UNIT(p)->id);
694 /* Hmm, so inotify was triggered since the
695 * last activation, so I guess we need to
696 * recheck what is going on. */
697 path_enter_waiting(p, false, p->inotify_triggered);
702 static void path_reset_failed(Unit *u) {
707 if (p->state == PATH_FAILED)
708 path_set_state(p, PATH_DEAD);
710 p->result = PATH_SUCCESS;
713 static const char* const path_state_table[_PATH_STATE_MAX] = {
714 [PATH_DEAD] = "dead",
715 [PATH_WAITING] = "waiting",
716 [PATH_RUNNING] = "running",
717 [PATH_FAILED] = "failed"
720 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
722 static const char* const path_type_table[_PATH_TYPE_MAX] = {
723 [PATH_EXISTS] = "PathExists",
724 [PATH_EXISTS_GLOB] = "PathExistsGlob",
725 [PATH_CHANGED] = "PathChanged",
726 [PATH_MODIFIED] = "PathModified",
727 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
730 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
732 static const char* const path_result_table[_PATH_RESULT_MAX] = {
733 [PATH_SUCCESS] = "success",
734 [PATH_FAILURE_RESOURCES] = "resources"
737 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
739 const UnitVTable path_vtable = {
741 .object_size = sizeof(Path),
751 .coldplug = path_coldplug,
758 .serialize = path_serialize,
759 .deserialize_item = path_deserialize_item,
761 .active_state = path_active_state,
762 .sub_state_to_string = path_sub_state_to_string,
764 .fd_event = path_fd_event,
766 .reset_failed = path_reset_failed,
768 .bus_interface = "org.freedesktop.systemd1.Path",
769 .bus_message_handler = bus_path_message_handler,
770 .bus_invalidating_properties = bus_path_invalidating_properties