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 void path_free_specs(Path *p) {
256 while ((s = p->specs)) {
257 path_spec_unwatch(s, UNIT(p));
258 LIST_REMOVE(PathSpec, spec, p->specs, s);
264 static void path_done(Unit *u) {
269 unit_ref_unset(&p->unit);
273 int path_add_one_mount_link(Path *p, Mount *m) {
280 if (UNIT(p)->load_state != UNIT_LOADED ||
281 UNIT(m)->load_state != UNIT_LOADED)
284 LIST_FOREACH(spec, s, p->specs) {
286 if (!path_spec_startswith(s, m->where))
289 if ((r = unit_add_two_dependencies(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
296 static int path_add_mount_links(Path *p) {
302 LIST_FOREACH(units_by_type, other, UNIT(p)->manager->units_by_type[UNIT_MOUNT])
303 if ((r = path_add_one_mount_link(p, MOUNT(other))) < 0)
309 static int path_verify(Path *p) {
312 if (UNIT(p)->load_state != UNIT_LOADED)
316 log_error_unit(UNIT(p)->id,
317 "%s lacks path setting. Refusing.", UNIT(p)->id);
324 static int path_add_default_dependencies(Path *p) {
329 if (UNIT(p)->manager->running_as == SYSTEMD_SYSTEM) {
330 if ((r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
333 if ((r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
337 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
340 static int path_load(Unit *u) {
345 assert(u->load_state == UNIT_STUB);
347 if ((r = unit_load_fragment_and_dropin(u)) < 0)
350 if (u->load_state == UNIT_LOADED) {
352 if (!UNIT_DEREF(p->unit)) {
355 r = unit_load_related_unit(u, ".service", &x);
359 unit_ref_set(&p->unit, x);
362 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(p->unit), true);
366 if ((r = path_add_mount_links(p)) < 0)
369 if (UNIT(p)->default_dependencies)
370 if ((r = path_add_default_dependencies(p)) < 0)
374 return path_verify(p);
377 static void path_dump(Unit *u, FILE *f, const char *prefix) {
388 "%sMakeDirectory: %s\n"
389 "%sDirectoryMode: %04o\n",
390 prefix, path_state_to_string(p->state),
391 prefix, path_result_to_string(p->result),
392 prefix, UNIT_DEREF(p->unit)->id,
393 prefix, yes_no(p->make_directory),
394 prefix, p->directory_mode);
396 LIST_FOREACH(spec, s, p->specs)
397 path_spec_dump(s, f, prefix);
400 static void path_unwatch(Path *p) {
405 LIST_FOREACH(spec, s, p->specs)
406 path_spec_unwatch(s, UNIT(p));
409 static int path_watch(Path *p) {
415 LIST_FOREACH(spec, s, p->specs)
416 if ((r = path_spec_watch(s, UNIT(p))) < 0)
422 static void path_set_state(Path *p, PathState state) {
426 old_state = p->state;
429 if (state != PATH_WAITING &&
430 (state != PATH_RUNNING || p->inotify_triggered))
433 if (state != old_state)
434 log_debug("%s changed %s -> %s",
436 path_state_to_string(old_state),
437 path_state_to_string(state));
439 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
442 static void path_enter_waiting(Path *p, bool initial, bool recheck);
444 static int path_coldplug(Unit *u) {
448 assert(p->state == PATH_DEAD);
450 if (p->deserialized_state != p->state) {
452 if (p->deserialized_state == PATH_WAITING ||
453 p->deserialized_state == PATH_RUNNING)
454 path_enter_waiting(p, true, true);
456 path_set_state(p, p->deserialized_state);
462 static void path_enter_dead(Path *p, PathResult f) {
465 if (f != PATH_SUCCESS)
468 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
471 static void path_enter_running(Path *p) {
476 dbus_error_init(&error);
478 /* Don't start job if we are supposed to go down */
479 if (UNIT(p)->job && UNIT(p)->job->type == JOB_STOP)
482 if ((r = manager_add_job(UNIT(p)->manager, JOB_START, UNIT_DEREF(p->unit), JOB_REPLACE, true, &error, NULL)) < 0)
485 p->inotify_triggered = false;
487 if ((r = path_watch(p)) < 0)
490 path_set_state(p, PATH_RUNNING);
494 log_warning("%s failed to queue unit startup job: %s", UNIT(p)->id, bus_error(&error, r));
495 path_enter_dead(p, PATH_FAILURE_RESOURCES);
497 dbus_error_free(&error);
500 static bool path_check_good(Path *p, bool initial) {
506 LIST_FOREACH(spec, s, p->specs) {
507 good = path_spec_check_good(s, initial);
516 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
520 if (path_check_good(p, initial)) {
521 log_debug("%s got triggered.", UNIT(p)->id);
522 path_enter_running(p);
526 if ((r = path_watch(p)) < 0)
529 /* Hmm, so now we have created inotify watches, but the file
530 * might have appeared/been removed by now, so we must
534 if (path_check_good(p, false)) {
535 log_debug("%s got triggered.", UNIT(p)->id);
536 path_enter_running(p);
540 path_set_state(p, PATH_WAITING);
544 log_warning("%s failed to enter waiting state: %s", UNIT(p)->id, strerror(-r));
545 path_enter_dead(p, PATH_FAILURE_RESOURCES);
548 static void path_mkdir(Path *p) {
553 if (!p->make_directory)
556 LIST_FOREACH(spec, s, p->specs)
557 path_spec_mkdir(s, p->directory_mode);
560 static int path_start(Unit *u) {
564 assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
566 if (UNIT_DEREF(p->unit)->load_state != UNIT_LOADED)
571 p->result = PATH_SUCCESS;
572 path_enter_waiting(p, true, true);
577 static int path_stop(Unit *u) {
581 assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
583 path_enter_dead(p, PATH_SUCCESS);
587 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
594 unit_serialize_item(u, f, "state", path_state_to_string(p->state));
595 unit_serialize_item(u, f, "result", path_result_to_string(p->result));
600 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
608 if (streq(key, "state")) {
611 if ((state = path_state_from_string(value)) < 0)
612 log_debug("Failed to parse state value %s", value);
614 p->deserialized_state = state;
616 } else if (streq(key, "result")) {
619 f = path_result_from_string(value);
621 log_debug("Failed to parse result value %s", value);
622 else if (f != PATH_SUCCESS)
626 log_debug("Unknown serialization key '%s'", key);
631 static UnitActiveState path_active_state(Unit *u) {
634 return state_translation_table[PATH(u)->state];
637 static const char *path_sub_state_to_string(Unit *u) {
640 return path_state_to_string(PATH(u)->state);
643 static void path_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
651 if (p->state != PATH_WAITING &&
652 p->state != PATH_RUNNING)
655 /* log_debug("inotify wakeup on %s.", u->id); */
657 LIST_FOREACH(spec, s, p->specs)
658 if (path_spec_owns_inotify_fd(s, fd))
662 log_error("Got event on unknown fd.");
666 changed = path_spec_fd_event(s, events);
670 /* If we are already running, then remember that one event was
671 * dispatched so that we restart the service only if something
672 * actually changed on disk */
673 p->inotify_triggered = true;
676 path_enter_running(p);
678 path_enter_waiting(p, false, true);
683 path_enter_dead(p, PATH_FAILURE_RESOURCES);
686 void path_unit_notify(Unit *u, UnitActiveState new_state) {
690 if (u->type == UNIT_PATH)
693 SET_FOREACH(k, u->dependencies[UNIT_TRIGGERED_BY], i) {
696 if (k->type != UNIT_PATH)
699 if (k->load_state != UNIT_LOADED)
704 if (p->state == PATH_RUNNING && new_state == UNIT_INACTIVE) {
705 log_debug("%s got notified about unit deactivation.", UNIT(p)->id);
707 /* Hmm, so inotify was triggered since the
708 * last activation, so I guess we need to
709 * recheck what is going on. */
710 path_enter_waiting(p, false, p->inotify_triggered);
715 static void path_reset_failed(Unit *u) {
720 if (p->state == PATH_FAILED)
721 path_set_state(p, PATH_DEAD);
723 p->result = PATH_SUCCESS;
726 static const char* const path_state_table[_PATH_STATE_MAX] = {
727 [PATH_DEAD] = "dead",
728 [PATH_WAITING] = "waiting",
729 [PATH_RUNNING] = "running",
730 [PATH_FAILED] = "failed"
733 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
735 static const char* const path_type_table[_PATH_TYPE_MAX] = {
736 [PATH_EXISTS] = "PathExists",
737 [PATH_EXISTS_GLOB] = "PathExistsGlob",
738 [PATH_CHANGED] = "PathChanged",
739 [PATH_MODIFIED] = "PathModified",
740 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
743 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
745 static const char* const path_result_table[_PATH_RESULT_MAX] = {
746 [PATH_SUCCESS] = "success",
747 [PATH_FAILURE_RESOURCES] = "resources"
750 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
752 const UnitVTable path_vtable = {
753 .object_size = sizeof(Path),
763 .coldplug = path_coldplug,
770 .serialize = path_serialize,
771 .deserialize_item = path_deserialize_item,
773 .active_state = path_active_state,
774 .sub_state_to_string = path_sub_state_to_string,
776 .fd_event = path_fd_event,
778 .reset_failed = path_reset_failed,
780 .bus_interface = "org.freedesktop.systemd1.Path",
781 .bus_message_handler = bus_path_message_handler,
782 .bus_invalidating_properties = bus_path_invalidating_properties