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"
37 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
38 [PATH_DEAD] = UNIT_INACTIVE,
39 [PATH_WAITING] = UNIT_ACTIVE,
40 [PATH_RUNNING] = UNIT_ACTIVE,
41 [PATH_FAILED] = UNIT_FAILED
44 int path_spec_watch(PathSpec *s, Unit *u) {
46 static const int flags_table[_PATH_TYPE_MAX] = {
47 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
48 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
49 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
50 [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,
51 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
61 path_spec_unwatch(s, u);
63 if (!(k = strdup(s->path)))
66 if ((s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC)) < 0) {
71 if (unit_watch_fd(u, s->inotify_fd, EPOLLIN, &s->watch) < 0) {
76 s->primary_wd = inotify_add_watch(s->inotify_fd, k, flags_table[s->type]);
77 if (s->primary_wd >= 0)
83 /* This assumes the path was passed through path_kill_slashes()! */
84 slash = strrchr(k, '/');
88 /* Trim the path at the last slash. Keep the slash if it's the root dir. */
89 slash[slash == k] = 0;
93 flags |= IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
95 if (inotify_add_watch(s->inotify_fd, k, flags) >= 0)
104 path_spec_unwatch(s, u);
108 void path_spec_unwatch(PathSpec *s, Unit *u) {
110 if (s->inotify_fd < 0)
113 unit_unwatch_fd(u, &s->watch);
115 close_nointr_nofail(s->inotify_fd);
119 int path_spec_fd_event(PathSpec *s, uint32_t events) {
121 struct inotify_event *e;
126 if (events != EPOLLIN) {
127 log_error("Got invalid poll event on inotify.");
132 if (ioctl(s->inotify_fd, FIONREAD, &l) < 0) {
133 log_error("FIONREAD failed: %m");
142 log_error("Failed to allocate buffer: %m");
147 k = read(s->inotify_fd, buf, l);
149 log_error("Failed to read inotify event: %m");
154 e = (struct inotify_event*) buf;
159 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
160 s->primary_wd == e->wd)
163 step = sizeof(struct inotify_event) + e->len;
164 assert(step <= (size_t) k);
166 e = (struct inotify_event*) ((uint8_t*) e + step);
174 static bool path_spec_check_good(PathSpec *s, bool initial) {
180 good = access(s->path, F_OK) >= 0;
183 case PATH_EXISTS_GLOB:
184 good = glob_exists(s->path) > 0;
187 case PATH_DIRECTORY_NOT_EMPTY: {
190 k = dir_is_empty(s->path);
191 good = !(k == -ENOENT || k > 0);
196 case PATH_MODIFIED: {
199 b = access(s->path, F_OK) >= 0;
200 good = !initial && b != s->previous_exists;
201 s->previous_exists = b;
212 static bool path_spec_startswith(PathSpec *s, const char *what) {
213 return path_startswith(s->path, what);
216 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
219 if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
222 r = mkdir_p_label(s->path, mode);
224 log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
227 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
231 path_type_to_string(s->type),
235 void path_spec_done(PathSpec *s) {
237 assert(s->inotify_fd == -1);
242 static void path_init(Unit *u) {
246 assert(u->load_state == UNIT_STUB);
248 p->directory_mode = 0755;
251 static void path_done(Unit *u) {
257 unit_ref_unset(&p->unit);
259 while ((s = p->specs)) {
260 path_spec_unwatch(s, u);
261 LIST_REMOVE(PathSpec, spec, p->specs, s);
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("%s lacks path setting. Refusing.", UNIT(p)->id);
317 static int path_add_default_dependencies(Path *p) {
322 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
323 if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
326 if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
330 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
333 static int path_load(Unit *u) {
338 assert(u->load_state == UNIT_STUB);
340 if ((r = unit_load_fragment_and_dropin(u)) < 0)
343 if (u->load_state == UNIT_LOADED) {
345 if (!UNIT_DEREF(p->unit)) {
348 r = unit_load_related_unit(u, ".service", &x);
352 unit_ref_set(&p->unit, x);
355 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(p->unit), true);
359 if ((r = path_add_mount_links(p)) < 0)
362 if (UNIT(p)->default_dependencies)
363 if ((r = path_add_default_dependencies(p)) < 0)
367 return path_verify(p);
370 static void path_dump(Unit *u, FILE *f, const char *prefix) {
381 "%sMakeDirectory: %s\n"
382 "%sDirectoryMode: %04o\n",
383 prefix, path_state_to_string(p->state),
384 prefix, path_result_to_string(p->result),
385 prefix, UNIT_DEREF(p->unit)->id,
386 prefix, yes_no(p->make_directory),
387 prefix, p->directory_mode);
389 LIST_FOREACH(spec, s, p->specs)
390 path_spec_dump(s, f, prefix);
393 static void path_unwatch(Path *p) {
398 LIST_FOREACH(spec, s, p->specs)
399 path_spec_unwatch(s, UNIT(p));
402 static int path_watch(Path *p) {
408 LIST_FOREACH(spec, s, p->specs)
409 if ((r = path_spec_watch(s, UNIT(p))) < 0)
415 static void path_set_state(Path *p, PathState state) {
419 old_state = p->state;
422 if (state != PATH_WAITING &&
423 (state != PATH_RUNNING || p->inotify_triggered))
426 if (state != old_state)
427 log_debug("%s changed %s -> %s",
429 path_state_to_string(old_state),
430 path_state_to_string(state));
432 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
435 static void path_enter_waiting(Path *p, bool initial, bool recheck);
437 static int path_coldplug(Unit *u) {
441 assert(p->state == PATH_DEAD);
443 if (p->deserialized_state != p->state) {
445 if (p->deserialized_state == PATH_WAITING ||
446 p->deserialized_state == PATH_RUNNING)
447 path_enter_waiting(p, true, true);
449 path_set_state(p, p->deserialized_state);
455 static void path_enter_dead(Path *p, PathResult f) {
458 if (f != PATH_SUCCESS)
461 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
464 static void path_enter_running(Path *p) {
469 dbus_error_init(&error);
471 /* Don't start job if we are supposed to go down */
472 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
475 if ((r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit), JOB_REPLACE, true, &error, NULL)) < 0)
478 p->inotify_triggered = false;
480 if ((r = path_watch(p)) < 0)
483 path_set_state(p, PATH_RUNNING);
487 log_warning("%s failed to queue unit startup job: %s", UNIT(p)->id, bus_error(&error, r));
488 path_enter_dead(p, PATH_FAILURE_RESOURCES);
490 dbus_error_free(&error);
493 static bool path_check_good(Path *p, bool initial) {
499 LIST_FOREACH(spec, s, p->specs) {
500 good = path_spec_check_good(s, initial);
509 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
513 if (path_check_good(p, initial)) {
514 log_debug("%s got triggered.", UNIT(p)->id);
515 path_enter_running(p);
519 if ((r = path_watch(p)) < 0)
522 /* Hmm, so now we have created inotify watches, but the file
523 * might have appeared/been removed by now, so we must
527 if (path_check_good(p, false)) {
528 log_debug("%s got triggered.", UNIT(p)->id);
529 path_enter_running(p);
533 path_set_state(p, PATH_WAITING);
537 log_warning("%s failed to enter waiting state: %s", UNIT(p)->id, strerror(-r));
538 path_enter_dead(p, PATH_FAILURE_RESOURCES);
541 static void path_mkdir(Path *p) {
546 if (!p->make_directory)
549 LIST_FOREACH(spec, s, p->specs)
550 path_spec_mkdir(s, p->directory_mode);
553 static int path_start(Unit *u) {
557 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
559 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
564 p->result = PATH_SUCCESS;
565 path_enter_waiting(p, true, true);
570 static int path_stop(Unit *u) {
574 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
576 path_enter_dead(p, PATH_SUCCESS);
580 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
587 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
588 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
593 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
601 if (streq(key, "state")) {
604 if ((state = path_state_from_string(value)) < 0)
605 log_debug("Failed to parse state value %s", value);
607 p->deserialized_state = state;
609 } else if (streq(key, "result")) {
612 f = path_result_from_string(value);
614 log_debug("Failed to parse result value %s", value);
615 else if (f != PATH_SUCCESS)
619 log_debug("Unknown serialization key '%s'", key);
624 static UnitActiveState path_active_state(Unit *u) {
627 return state_translation_table[PATH(u)->state];
630 static const char *path_sub_state_to_string(Unit *u) {
633 return path_state_to_string(PATH(u)->state);
636 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
644 if (p->state != PATH_WAITING &&
645 p->state != PATH_RUNNING)
648 /* log_debug("inotify wakeup on %s.", u->id); */
650 LIST_FOREACH(spec, s, p->specs)
651 if (path_spec_owns_inotify_fd(s, fd))
655 log_error("Got event on unknown fd.");
659 changed = path_spec_fd_event(s, events);
663 /* If we are already running, then remember that one event was
664 * dispatched so that we restart the service only if something
665 * actually changed on disk */
666 p->inotify_triggered = true;
669 path_enter_running(p);
671 path_enter_waiting(p, false, true);
676 path_enter_dead(p, PATH_FAILURE_RESOURCES);
679 void path_unit_notify(Unit *u, UnitActiveState new_state) {
683 if (u->type == UNIT_PATH)
686 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
689 if (k->type != UNIT_PATH)
692 if (k->load_state != UNIT_LOADED)
697 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
698 log_debug("%s got notified about unit deactivation.", UNIT(p)->id);
700 /* Hmm, so inotify was triggered since the
701 * last activation, so I guess we need to
702 * recheck what is going on. */
703 path_enter_waiting(p, false, p->inotify_triggered);
708 static void path_reset_failed(Unit *u) {
713 if (p->state == PATH_FAILED)
714 path_set_state(p, PATH_DEAD);
716 p->result = PATH_SUCCESS;
719 static const char* const path_state_table[_PATH_STATE_MAX] = {
720 [PATH_DEAD] = "dead",
721 [PATH_WAITING] = "waiting",
722 [PATH_RUNNING] = "running",
723 [PATH_FAILED] = "failed"
726 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
728 static const char* const path_type_table[_PATH_TYPE_MAX] = {
729 [PATH_EXISTS] = "PathExists",
730 [PATH_EXISTS_GLOB] = "PathExistsGlob",
731 [PATH_CHANGED] = "PathChanged",
732 [PATH_MODIFIED] = "PathModified",
733 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
736 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
738 static const char* const path_result_table[_PATH_RESULT_MAX] = {
739 [PATH_SUCCESS] = "success",
740 [PATH_FAILURE_RESOURCES] = "resources"
743 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
745 const UnitVTable path_vtable = {
746 .object_size = sizeof(Path),
756 .coldplug = path_coldplug,
763 .serialize = path_serialize,
764 .deserialize_item = path_deserialize_item,
766 .active_state = path_active_state,
767 .sub_state_to_string = path_sub_state_to_string,
769 .fd_event = path_fd_event,
771 .reset_failed = path_reset_failed,
773 .bus_interface = "org.freedesktop.systemd1.Path",
774 .bus_message_handler = bus_path_message_handler,
775 .bus_invalidating_properties = bus_path_invalidating_properties