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>
28 #include "unit-name.h"
31 #include "dbus-path.h"
35 #include "bus-error.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 static int path_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
46 int path_spec_watch(PathSpec
*s
, sd_event_io_handler_t handler
) {
48 static const int flags_table
[_PATH_TYPE_MAX
] = {
49 [PATH_EXISTS
] = IN_DELETE_SELF
|IN_MOVE_SELF
|IN_ATTRIB
,
50 [PATH_EXISTS_GLOB
] = IN_DELETE_SELF
|IN_MOVE_SELF
|IN_ATTRIB
,
51 [PATH_CHANGED
] = IN_DELETE_SELF
|IN_MOVE_SELF
|IN_ATTRIB
|IN_CLOSE_WRITE
|IN_CREATE
|IN_DELETE
|IN_MOVED_FROM
|IN_MOVED_TO
,
52 [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
,
53 [PATH_DIRECTORY_NOT_EMPTY
] = IN_DELETE_SELF
|IN_MOVE_SELF
|IN_ATTRIB
|IN_CREATE
|IN_MOVED_TO
57 char *slash
, *oldslash
= NULL
;
66 s
->inotify_fd
= inotify_init1(IN_NONBLOCK
|IN_CLOEXEC
);
67 if (s
->inotify_fd
< 0) {
72 r
= sd_event_add_io(s
->unit
->manager
->event
, &s
->event_source
, s
->inotify_fd
, EPOLLIN
, handler
, s
);
76 (void) sd_event_source_set_description(s
->event_source
, "path");
78 /* This assumes the path was passed through path_kill_slashes()! */
80 for (slash
= strchr(s
->path
, '/'); ; slash
= strchr(slash
+1, '/')) {
86 cut
= slash
+ (slash
== s
->path
);
90 flags
= IN_MOVE_SELF
| IN_DELETE_SELF
| IN_ATTRIB
| IN_CREATE
| IN_MOVED_TO
;
92 flags
= flags_table
[s
->type
];
94 r
= inotify_add_watch(s
->inotify_fd
, s
->path
, flags
);
96 if (errno
== EACCES
|| errno
== ENOENT
) {
102 r
= log_warning_errno(errno
, "Failed to add watch on %s: %s", s
->path
, errno
== ENOSPC
? "too many watches" : strerror(-r
));
109 /* Path exists, we don't need to watch parent
112 char *cut2
= oldslash
+ (oldslash
== s
->path
);
116 inotify_add_watch(s
->inotify_fd
, s
->path
, IN_MOVE_SELF
);
117 /* Error is ignored, the worst can happen is
118 we get spurious events. */
130 /* whole path has been iterated over */
137 r
= log_error_errno(errno
, "Failed to add watch on any of the components of %s: %m", s
->path
);
138 /* either EACCESS or ENOENT */
145 path_spec_unwatch(s
);
149 void path_spec_unwatch(PathSpec
*s
) {
152 s
->event_source
= sd_event_source_unref(s
->event_source
);
153 s
->inotify_fd
= safe_close(s
->inotify_fd
);
156 int path_spec_fd_event(PathSpec
*s
, uint32_t revents
) {
157 union inotify_event_buffer buffer
;
158 struct inotify_event
*e
;
162 if (revents
!= EPOLLIN
) {
163 log_error("Got invalid poll event on inotify.");
167 l
= read(s
->inotify_fd
, &buffer
, sizeof(buffer
));
169 if (errno
== EAGAIN
|| errno
== EINTR
)
172 return log_error_errno(errno
, "Failed to read inotify event: %m");
175 FOREACH_INOTIFY_EVENT(e
, buffer
, l
) {
176 if ((s
->type
== PATH_CHANGED
|| s
->type
== PATH_MODIFIED
) &&
177 s
->primary_wd
== e
->wd
)
184 static bool path_spec_check_good(PathSpec
*s
, bool initial
) {
190 good
= access(s
->path
, F_OK
) >= 0;
193 case PATH_EXISTS_GLOB
:
194 good
= glob_exists(s
->path
) > 0;
197 case PATH_DIRECTORY_NOT_EMPTY
: {
200 k
= dir_is_empty(s
->path
);
201 good
= !(k
== -ENOENT
|| k
> 0);
206 case PATH_MODIFIED
: {
209 b
= access(s
->path
, F_OK
) >= 0;
210 good
= !initial
&& b
!= s
->previous_exists
;
211 s
->previous_exists
= b
;
222 static void path_spec_mkdir(PathSpec
*s
, mode_t mode
) {
225 if (s
->type
== PATH_EXISTS
|| s
->type
== PATH_EXISTS_GLOB
)
228 r
= mkdir_p_label(s
->path
, mode
);
230 log_warning_errno(r
, "mkdir(%s) failed: %m", s
->path
);
233 static void path_spec_dump(PathSpec
*s
, FILE *f
, const char *prefix
) {
237 path_type_to_string(s
->type
),
241 void path_spec_done(PathSpec
*s
) {
243 assert(s
->inotify_fd
== -1);
248 static void path_init(Unit
*u
) {
252 assert(u
->load_state
== UNIT_STUB
);
254 p
->directory_mode
= 0755;
257 void path_free_specs(Path
*p
) {
262 while ((s
= p
->specs
)) {
263 path_spec_unwatch(s
);
264 LIST_REMOVE(spec
, p
->specs
, s
);
270 static void path_done(Unit
*u
) {
278 static int path_add_mount_links(Path
*p
) {
284 LIST_FOREACH(spec
, s
, p
->specs
) {
285 r
= unit_require_mounts_for(UNIT(p
), s
->path
);
293 static int path_verify(Path
*p
) {
296 if (UNIT(p
)->load_state
!= UNIT_LOADED
)
300 log_unit_error(UNIT(p
), "Path unit lacks path setting. Refusing.");
307 static int path_add_default_dependencies(Path
*p
) {
312 r
= unit_add_dependency_by_name(UNIT(p
), UNIT_BEFORE
,
313 SPECIAL_PATHS_TARGET
, NULL
, true);
317 if (UNIT(p
)->manager
->running_as
== MANAGER_SYSTEM
) {
318 r
= unit_add_two_dependencies_by_name(UNIT(p
), UNIT_AFTER
, UNIT_REQUIRES
,
319 SPECIAL_SYSINIT_TARGET
, NULL
, true);
324 return unit_add_two_dependencies_by_name(UNIT(p
), UNIT_BEFORE
, UNIT_CONFLICTS
,
325 SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
328 static int path_load(Unit
*u
) {
333 assert(u
->load_state
== UNIT_STUB
);
335 r
= unit_load_fragment_and_dropin(u
);
339 if (u
->load_state
== UNIT_LOADED
) {
341 if (set_isempty(u
->dependencies
[UNIT_TRIGGERS
])) {
344 r
= unit_load_related_unit(u
, ".service", &x
);
348 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, x
, true);
353 r
= path_add_mount_links(p
);
357 if (UNIT(p
)->default_dependencies
) {
358 r
= path_add_default_dependencies(p
);
364 return path_verify(p
);
367 static void path_dump(Unit
*u
, FILE *f
, const char *prefix
) {
375 trigger
= UNIT_TRIGGER(u
);
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
, trigger
? trigger
->id
: "n/a",
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
);
402 static int path_watch(Path
*p
) {
408 LIST_FOREACH(spec
, s
, p
->specs
) {
409 r
= path_spec_watch(s
, path_dispatch_io
);
417 static void path_set_state(Path
*p
, PathState state
) {
421 old_state
= p
->state
;
424 if (state
!= PATH_WAITING
&&
425 (state
!= PATH_RUNNING
|| p
->inotify_triggered
))
428 if (state
!= old_state
)
429 log_unit_debug(UNIT(p
), "Changed %s -> %s", path_state_to_string(old_state
), path_state_to_string(state
));
431 unit_notify(UNIT(p
), state_translation_table
[old_state
], state_translation_table
[state
], true);
434 static void path_enter_waiting(Path
*p
, bool initial
, bool recheck
);
436 static int path_coldplug(Unit
*u
) {
440 assert(p
->state
== PATH_DEAD
);
442 if (p
->deserialized_state
!= p
->state
) {
444 if (p
->deserialized_state
== PATH_WAITING
||
445 p
->deserialized_state
== PATH_RUNNING
)
446 path_enter_waiting(p
, true, true);
448 path_set_state(p
, p
->deserialized_state
);
454 static void path_enter_dead(Path
*p
, PathResult f
) {
457 if (f
!= PATH_SUCCESS
)
460 path_set_state(p
, p
->result
!= PATH_SUCCESS
? PATH_FAILED
: PATH_DEAD
);
463 static void path_enter_running(Path
*p
) {
464 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
469 /* Don't start job if we are supposed to go down */
470 if (unit_stop_pending(UNIT(p
)))
473 r
= manager_add_job(UNIT(p
)->manager
, JOB_START
, UNIT_TRIGGER(UNIT(p
)),
474 JOB_REPLACE
, true, &error
, NULL
);
478 p
->inotify_triggered
= false;
484 path_set_state(p
, PATH_RUNNING
);
488 log_unit_warning(UNIT(p
), "Failed to queue unit startup job: %s", bus_error_message(&error
, r
));
489 path_enter_dead(p
, PATH_FAILURE_RESOURCES
);
492 static bool path_check_good(Path
*p
, bool initial
) {
498 LIST_FOREACH(spec
, s
, p
->specs
) {
499 good
= path_spec_check_good(s
, initial
);
508 static void path_enter_waiting(Path
*p
, bool initial
, bool recheck
) {
512 if (path_check_good(p
, initial
)) {
513 log_unit_debug(UNIT(p
), "Got triggered.");
514 path_enter_running(p
);
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_unit_debug(UNIT(p
), "Got triggered.");
529 path_enter_running(p
);
533 path_set_state(p
, PATH_WAITING
);
537 log_unit_warning_errno(UNIT(p
), r
, "Failed to enter waiting state: %m");
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_TRIGGER(u
)->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 state
= path_state_from_string(value
);
606 log_unit_debug(u
, "Failed to parse state value: %s", value
);
608 p
->deserialized_state
= state
;
610 } else if (streq(key
, "result")) {
613 f
= path_result_from_string(value
);
615 log_unit_debug(u
, "Failed to parse result value: %s", value
);
616 else if (f
!= PATH_SUCCESS
)
620 log_unit_debug(u
, "Unknown serialization key: %s", key
);
625 _pure_
static UnitActiveState
path_active_state(Unit
*u
) {
628 return state_translation_table
[PATH(u
)->state
];
631 _pure_
static const char *path_sub_state_to_string(Unit
*u
) {
634 return path_state_to_string(PATH(u
)->state
);
637 static int path_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
638 PathSpec
*s
= userdata
;
648 if (p
->state
!= PATH_WAITING
&&
649 p
->state
!= PATH_RUNNING
)
652 /* log_debug("inotify wakeup on %s.", u->id); */
654 LIST_FOREACH(spec
, s
, p
->specs
)
655 if (path_spec_owns_inotify_fd(s
, fd
))
659 log_error("Got event on unknown fd.");
663 changed
= path_spec_fd_event(s
, revents
);
667 /* If we are already running, then remember that one event was
668 * dispatched so that we restart the service only if something
669 * actually changed on disk */
670 p
->inotify_triggered
= true;
673 path_enter_running(p
);
675 path_enter_waiting(p
, false, true);
680 path_enter_dead(p
, PATH_FAILURE_RESOURCES
);
684 static void path_trigger_notify(Unit
*u
, Unit
*other
) {
690 /* Invoked whenever the unit we trigger changes state or gains
693 if (other
->load_state
!= UNIT_LOADED
)
696 if (p
->state
== PATH_RUNNING
&&
697 UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
))) {
698 log_unit_debug(UNIT(p
), "Got notified about unit deactivation.");
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
);
707 static void path_reset_failed(Unit
*u
) {
712 if (p
->state
== PATH_FAILED
)
713 path_set_state(p
, PATH_DEAD
);
715 p
->result
= PATH_SUCCESS
;
718 static const char* const path_state_table
[_PATH_STATE_MAX
] = {
719 [PATH_DEAD
] = "dead",
720 [PATH_WAITING
] = "waiting",
721 [PATH_RUNNING
] = "running",
722 [PATH_FAILED
] = "failed"
725 DEFINE_STRING_TABLE_LOOKUP(path_state
, PathState
);
727 static const char* const path_type_table
[_PATH_TYPE_MAX
] = {
728 [PATH_EXISTS
] = "PathExists",
729 [PATH_EXISTS_GLOB
] = "PathExistsGlob",
730 [PATH_DIRECTORY_NOT_EMPTY
] = "DirectoryNotEmpty",
731 [PATH_CHANGED
] = "PathChanged",
732 [PATH_MODIFIED
] = "PathModified",
735 DEFINE_STRING_TABLE_LOOKUP(path_type
, PathType
);
737 static const char* const path_result_table
[_PATH_RESULT_MAX
] = {
738 [PATH_SUCCESS
] = "success",
739 [PATH_FAILURE_RESOURCES
] = "resources",
742 DEFINE_STRING_TABLE_LOOKUP(path_result
, PathResult
);
744 const UnitVTable path_vtable
= {
745 .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 .trigger_notify
= path_trigger_notify
,
771 .reset_failed
= path_reset_failed
,
773 .bus_vtable
= bus_path_vtable