]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/path.c
update TODO
[thirdparty/systemd.git] / src / core / path.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <errno.h>
4 #include <sys/epoll.h>
5 #include <sys/inotify.h>
6 #include <unistd.h>
7
8 #include "bus-error.h"
9 #include "bus-util.h"
10 #include "dbus-path.h"
11 #include "dbus-unit.h"
12 #include "escape.h"
13 #include "event-util.h"
14 #include "fd-util.h"
15 #include "glob-util.h"
16 #include "inotify-util.h"
17 #include "macro.h"
18 #include "mkdir-label.h"
19 #include "path.h"
20 #include "path-util.h"
21 #include "serialize.h"
22 #include "special.h"
23 #include "stat-util.h"
24 #include "string-table.h"
25 #include "string-util.h"
26 #include "unit-name.h"
27 #include "unit.h"
28
29 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
30 [PATH_DEAD] = UNIT_INACTIVE,
31 [PATH_WAITING] = UNIT_ACTIVE,
32 [PATH_RUNNING] = UNIT_ACTIVE,
33 [PATH_FAILED] = UNIT_FAILED,
34 };
35
36 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
37
38 int path_spec_watch(PathSpec *s, sd_event_io_handler_t handler) {
39 static const int flags_table[_PATH_TYPE_MAX] = {
40 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
41 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
42 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
43 [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,
44 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO,
45 };
46
47 bool exists = false;
48 char *slash, *oldslash = NULL;
49 int r;
50
51 assert(s);
52 assert(s->unit);
53 assert(handler);
54
55 path_spec_unwatch(s);
56
57 s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
58 if (s->inotify_fd < 0) {
59 r = log_error_errno(errno, "Failed to allocate inotify fd: %m");
60 goto fail;
61 }
62
63 r = sd_event_add_io(s->unit->manager->event, &s->event_source, s->inotify_fd, EPOLLIN, handler, s);
64 if (r < 0) {
65 log_error_errno(r, "Failed to add inotify fd to event loop: %m");
66 goto fail;
67 }
68
69 (void) sd_event_source_set_description(s->event_source, "path");
70
71 /* This function assumes the path was passed through path_simplify()! */
72 assert(!strstr(s->path, "//"));
73
74 for (slash = strchr(s->path, '/'); ; slash = strchr(slash+1, '/')) {
75 bool incomplete = false;
76 int flags, wd = -1;
77 char tmp, *cut;
78
79 if (slash) {
80 cut = slash + (slash == s->path);
81 tmp = *cut;
82 *cut = '\0';
83
84 flags = IN_MOVE_SELF | IN_DELETE_SELF | IN_CREATE | IN_MOVED_TO;
85 } else {
86 cut = NULL;
87 flags = flags_table[s->type];
88 }
89
90 /* If this is a symlink watch both the symlink inode and where it points to. If the inode is
91 * not a symlink both calls will install the same watch, which is redundant and doesn't
92 * hurt. */
93 for (int follow_symlink = 0; follow_symlink < 2; follow_symlink++) {
94 uint32_t f = flags;
95
96 SET_FLAG(f, IN_DONT_FOLLOW, !follow_symlink);
97
98 wd = inotify_add_watch(s->inotify_fd, s->path, f);
99 if (wd < 0) {
100 if (IN_SET(errno, EACCES, ENOENT)) {
101 incomplete = true; /* This is an expected error, let's accept this
102 * quietly: we have an incomplete watch for
103 * now. */
104 break;
105 }
106
107 /* This second call to inotify_add_watch() should fail like the previous one
108 * and is done for logging the error in a comprehensive way. */
109 wd = inotify_add_watch_and_warn(s->inotify_fd, s->path, f);
110 if (wd < 0) {
111 if (cut)
112 *cut = tmp;
113
114 r = wd;
115 goto fail;
116 }
117
118 /* Hmm, we succeeded in adding the watch this time... let's continue. */
119 }
120 }
121
122 if (incomplete) {
123 if (cut)
124 *cut = tmp;
125
126 break;
127 }
128
129 exists = true;
130
131 /* Path exists, we don't need to watch parent too closely. */
132 if (oldslash) {
133 char *cut2 = oldslash + (oldslash == s->path);
134 char tmp2 = *cut2;
135 *cut2 = '\0';
136
137 (void) inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
138 /* Error is ignored, the worst can happen is we get spurious events. */
139
140 *cut2 = tmp2;
141 }
142
143 if (cut)
144 *cut = tmp;
145
146 if (slash)
147 oldslash = slash;
148 else {
149 /* whole path has been iterated over */
150 s->primary_wd = wd;
151 break;
152 }
153 }
154
155 if (!exists) {
156 r = log_error_errno(errno, "Failed to add watch on any of the components of %s: %m", s->path);
157 /* either EACCESS or ENOENT */
158 goto fail;
159 }
160
161 return 0;
162
163 fail:
164 path_spec_unwatch(s);
165 return r;
166 }
167
168 void path_spec_unwatch(PathSpec *s) {
169 assert(s);
170
171 s->event_source = sd_event_source_disable_unref(s->event_source);
172 s->inotify_fd = safe_close(s->inotify_fd);
173 }
174
175 int path_spec_fd_event(PathSpec *s, uint32_t revents) {
176 union inotify_event_buffer buffer;
177 ssize_t l;
178
179 assert(s);
180
181 if (revents != EPOLLIN)
182 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
183 "Got invalid poll event on inotify.");
184
185 l = read(s->inotify_fd, &buffer, sizeof(buffer));
186 if (l < 0) {
187 if (ERRNO_IS_TRANSIENT(errno))
188 return 0;
189
190 return log_error_errno(errno, "Failed to read inotify event: %m");
191 }
192
193 if (IN_SET(s->type, PATH_CHANGED, PATH_MODIFIED))
194 FOREACH_INOTIFY_EVENT_WARN(e, buffer, l)
195 if (s->primary_wd == e->wd)
196 return 1;
197
198 return 0;
199 }
200
201 static bool path_spec_check_good(PathSpec *s, bool initial, bool from_trigger_notify, char **ret_trigger_path) {
202 _cleanup_free_ char *trigger = NULL;
203 bool b, good = false;
204
205 assert(s);
206 assert(ret_trigger_path);
207
208 switch (s->type) {
209
210 case PATH_EXISTS:
211 good = access(s->path, F_OK) >= 0;
212 break;
213
214 case PATH_EXISTS_GLOB:
215 good = glob_first(s->path, &trigger) > 0;
216 break;
217
218 case PATH_DIRECTORY_NOT_EMPTY: {
219 int k;
220
221 k = dir_is_empty(s->path, /* ignore_hidden_or_backup= */ true);
222 good = !(IN_SET(k, -ENOENT, -ENOTDIR) || k > 0);
223 break;
224 }
225
226 case PATH_CHANGED:
227 case PATH_MODIFIED:
228 b = access(s->path, F_OK) >= 0;
229 good = !initial && !from_trigger_notify && b != s->previous_exists;
230 s->previous_exists = b;
231 break;
232
233 default:
234 ;
235 }
236
237 if (good) {
238 if (!trigger) {
239 trigger = strdup(s->path);
240 if (!trigger)
241 (void) log_oom_debug();
242 }
243 *ret_trigger_path = TAKE_PTR(trigger);
244 }
245
246 return good;
247 }
248
249 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
250 int r;
251
252 assert(s);
253
254 if (IN_SET(s->type, PATH_EXISTS, PATH_EXISTS_GLOB))
255 return;
256
257 r = mkdir_p_label(s->path, mode);
258 if (r < 0)
259 log_warning_errno(r, "mkdir(%s) failed: %m", s->path);
260 }
261
262 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
263 const char *type;
264
265 assert(s);
266 assert(f);
267 assert(prefix);
268
269 assert_se(type = path_type_to_string(s->type));
270 fprintf(f, "%s%s: %s\n", prefix, type, s->path);
271 }
272
273 void path_spec_done(PathSpec *s) {
274 assert(s);
275 assert(s->inotify_fd == -EBADF);
276
277 free(s->path);
278 }
279
280 static void path_init(Unit *u) {
281 Path *p = ASSERT_PTR(PATH(u));
282
283 assert(u->load_state == UNIT_STUB);
284
285 p->directory_mode = 0755;
286
287 p->trigger_limit = RATELIMIT_OFF;
288 }
289
290 void path_free_specs(Path *p) {
291 PathSpec *s;
292
293 assert(p);
294
295 while ((s = LIST_POP(spec, p->specs))) {
296 path_spec_unwatch(s);
297 path_spec_done(s);
298 free(s);
299 }
300 }
301
302 static void path_done(Unit *u) {
303 Path *p = ASSERT_PTR(PATH(u));
304
305 p->trigger_notify_event_source = sd_event_source_disable_unref(p->trigger_notify_event_source);
306 path_free_specs(p);
307 }
308
309 static int path_add_mount_dependencies(Path *p) {
310 int r;
311
312 assert(p);
313
314 LIST_FOREACH(spec, s, p->specs) {
315 r = unit_add_mounts_for(UNIT(p), s->path, UNIT_DEPENDENCY_FILE, UNIT_MOUNT_REQUIRES);
316 if (r < 0)
317 return r;
318 }
319
320 return 0;
321 }
322
323 static int path_verify(Path *p) {
324 assert(p);
325 assert(UNIT(p)->load_state == UNIT_LOADED);
326
327 if (!p->specs)
328 return log_unit_error_errno(UNIT(p), SYNTHETIC_ERRNO(ENOEXEC), "Path unit lacks path setting. Refusing.");
329
330 return 0;
331 }
332
333 static int path_add_default_dependencies(Path *p) {
334 int r;
335
336 assert(p);
337
338 if (!UNIT(p)->default_dependencies)
339 return 0;
340
341 r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_PATHS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
342 if (r < 0)
343 return r;
344
345 if (MANAGER_IS_SYSTEM(UNIT(p)->manager)) {
346 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
347 if (r < 0)
348 return r;
349 }
350
351 return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
352 }
353
354 static int path_add_trigger_dependencies(Path *p) {
355 Unit *x;
356 int r;
357
358 assert(p);
359
360 if (UNIT_TRIGGER(UNIT(p)))
361 return 0;
362
363 r = unit_load_related_unit(UNIT(p), ".service", &x);
364 if (r < 0)
365 return r;
366
367 return unit_add_two_dependencies(UNIT(p), UNIT_BEFORE, UNIT_TRIGGERS, x, true, UNIT_DEPENDENCY_IMPLICIT);
368 }
369
370 static int path_add_extras(Path *p) {
371 int r;
372
373 assert(p);
374
375 /* To avoid getting pid1 in a busy-loop state (eg: unmet condition on associated service),
376 * set a default trigger limit if the user didn't specify any. */
377 if (p->trigger_limit.interval == USEC_INFINITY)
378 p->trigger_limit.interval = 2 * USEC_PER_SEC;
379
380 if (p->trigger_limit.burst == UINT_MAX)
381 p->trigger_limit.burst = 200;
382
383 r = path_add_trigger_dependencies(p);
384 if (r < 0)
385 return r;
386
387 r = path_add_mount_dependencies(p);
388 if (r < 0)
389 return r;
390
391 return path_add_default_dependencies(p);
392 }
393
394 static int path_load(Unit *u) {
395 Path *p = ASSERT_PTR(PATH(u));
396 int r;
397
398 assert(u->load_state == UNIT_STUB);
399
400 r = unit_load_fragment_and_dropin(u, true);
401 if (r < 0)
402 return r;
403
404 if (u->load_state != UNIT_LOADED)
405 return 0;
406
407 r = path_add_extras(p);
408 if (r < 0)
409 return r;
410
411 return path_verify(p);
412 }
413
414 static void path_dump(Unit *u, FILE *f, const char *prefix) {
415 Path *p = ASSERT_PTR(PATH(u));
416 Unit *trigger;
417
418 assert(f);
419 assert(prefix);
420
421 trigger = UNIT_TRIGGER(u);
422
423 fprintf(f,
424 "%sPath State: %s\n"
425 "%sResult: %s\n"
426 "%sUnit: %s\n"
427 "%sMakeDirectory: %s\n"
428 "%sDirectoryMode: %04o\n"
429 "%sTriggerLimitIntervalSec: %s\n"
430 "%sTriggerLimitBurst: %u\n",
431 prefix, path_state_to_string(p->state),
432 prefix, path_result_to_string(p->result),
433 prefix, trigger ? trigger->id : "n/a",
434 prefix, yes_no(p->make_directory),
435 prefix, p->directory_mode,
436 prefix, FORMAT_TIMESPAN(p->trigger_limit.interval, USEC_PER_SEC),
437 prefix, p->trigger_limit.burst);
438
439 LIST_FOREACH(spec, s, p->specs)
440 path_spec_dump(s, f, prefix);
441 }
442
443 static void path_unwatch(Path *p) {
444 assert(p);
445
446 LIST_FOREACH(spec, s, p->specs)
447 path_spec_unwatch(s);
448 }
449
450 static int path_watch(Path *p) {
451 int r;
452
453 assert(p);
454
455 LIST_FOREACH(spec, s, p->specs) {
456 r = path_spec_watch(s, path_dispatch_io);
457 if (r < 0)
458 return r;
459 }
460
461 return 0;
462 }
463
464 static void path_set_state(Path *p, PathState state) {
465 PathState old_state;
466
467 assert(p);
468
469 if (p->state != state)
470 bus_unit_send_pending_change_signal(UNIT(p), false);
471
472 old_state = p->state;
473 p->state = state;
474
475 if (!IN_SET(state, PATH_WAITING, PATH_RUNNING))
476 path_unwatch(p);
477
478 if (state != old_state)
479 log_unit_debug(UNIT(p), "Changed %s -> %s", path_state_to_string(old_state), path_state_to_string(state));
480
481 unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], /* reload_success = */ true);
482 }
483
484 static void path_enter_waiting(Path *p, bool initial, bool from_trigger_notify);
485
486 static int path_coldplug(Unit *u) {
487 Path *p = ASSERT_PTR(PATH(u));
488
489 assert(p->state == PATH_DEAD);
490
491 if (p->deserialized_state != p->state) {
492
493 if (IN_SET(p->deserialized_state, PATH_WAITING, PATH_RUNNING))
494 path_enter_waiting(p, true, false);
495 else
496 path_set_state(p, p->deserialized_state);
497 }
498
499 return 0;
500 }
501
502 static void path_enter_dead(Path *p, PathResult f) {
503 assert(p);
504
505 if (p->result == PATH_SUCCESS)
506 p->result = f;
507
508 unit_log_result(UNIT(p), p->result == PATH_SUCCESS, path_result_to_string(p->result));
509 path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
510 }
511
512 static void path_enter_running(Path *p, char *trigger_path) {
513 _cleanup_(activation_details_unrefp) ActivationDetails *details = NULL;
514 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
515 Unit *trigger;
516 Job *job;
517 int r;
518
519 assert(p);
520
521 /* Don't start job if we are supposed to go down */
522 if (unit_stop_pending(UNIT(p)))
523 return;
524
525 if (!ratelimit_below(&p->trigger_limit)) {
526 log_unit_warning(UNIT(p), "Trigger limit hit, refusing further activation.");
527 path_enter_dead(p, PATH_FAILURE_TRIGGER_LIMIT_HIT);
528 return;
529 }
530
531 trigger = UNIT_TRIGGER(UNIT(p));
532 if (!trigger) {
533 log_unit_error(UNIT(p), "Unit to trigger vanished.");
534 goto fail;
535 }
536
537 details = activation_details_new(UNIT(p));
538 if (!details) {
539 log_oom();
540 goto fail;
541 }
542
543 r = free_and_strdup(&(ACTIVATION_DETAILS_PATH(details))->trigger_path_filename, trigger_path);
544 if (r < 0) {
545 log_oom();
546 goto fail;
547 }
548
549 r = manager_add_job(UNIT(p)->manager, JOB_START, trigger, JOB_REPLACE, NULL, &error, &job);
550 if (r < 0) {
551 log_unit_warning(UNIT(p), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
552 goto fail;
553 }
554
555 job_set_activation_details(job, details);
556
557 path_set_state(p, PATH_RUNNING);
558 path_unwatch(p);
559
560 return;
561
562 fail:
563 path_enter_dead(p, PATH_FAILURE_RESOURCES);
564 }
565
566 static bool path_check_good(Path *p, bool initial, bool from_trigger_notify, char **ret_trigger_path) {
567 assert(p);
568 assert(ret_trigger_path);
569
570 LIST_FOREACH(spec, s, p->specs)
571 if (path_spec_check_good(s, initial, from_trigger_notify, ret_trigger_path))
572 return true;
573
574 return false;
575 }
576
577 static void path_enter_waiting(Path *p, bool initial, bool from_trigger_notify) {
578 _cleanup_free_ char *trigger_path = NULL;
579 Unit *trigger;
580 int r;
581
582 if (p->trigger_notify_event_source)
583 (void) event_source_disable(p->trigger_notify_event_source);
584
585 /* If the triggered unit is already running, so are we */
586 trigger = UNIT_TRIGGER(UNIT(p));
587 if (trigger && !UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(trigger))) {
588 path_set_state(p, PATH_RUNNING);
589 path_unwatch(p);
590 return;
591 }
592
593 if (path_check_good(p, initial, from_trigger_notify, &trigger_path)) {
594 log_unit_debug(UNIT(p), "Got triggered.");
595 path_enter_running(p, trigger_path);
596 return;
597 }
598
599 r = path_watch(p);
600 if (r < 0) {
601 log_unit_warning_errno(UNIT(p), r, "Failed to enter waiting state: %m");
602 path_enter_dead(p, PATH_FAILURE_RESOURCES);
603 return;
604 }
605
606 /* Hmm, so now we have created inotify watches, but the file
607 * might have appeared/been removed by now, so we must
608 * recheck */
609
610 if (path_check_good(p, false, from_trigger_notify, &trigger_path)) {
611 log_unit_debug(UNIT(p), "Got triggered.");
612 path_enter_running(p, trigger_path);
613 return;
614 }
615
616 path_set_state(p, PATH_WAITING);
617 }
618
619 static void path_mkdir(Path *p) {
620 assert(p);
621
622 if (!p->make_directory)
623 return;
624
625 LIST_FOREACH(spec, s, p->specs)
626 path_spec_mkdir(s, p->directory_mode);
627 }
628
629 static int path_start(Unit *u) {
630 Path *p = ASSERT_PTR(PATH(u));
631 int r;
632
633 assert(IN_SET(p->state, PATH_DEAD, PATH_FAILED));
634
635 r = unit_test_trigger_loaded(u);
636 if (r < 0)
637 return r;
638
639 r = unit_acquire_invocation_id(u);
640 if (r < 0)
641 return r;
642
643 path_mkdir(p);
644
645 p->result = PATH_SUCCESS;
646 path_enter_waiting(p, true, false);
647
648 return 1;
649 }
650
651 static int path_stop(Unit *u) {
652 Path *p = ASSERT_PTR(PATH(u));
653
654 assert(IN_SET(p->state, PATH_WAITING, PATH_RUNNING));
655
656 path_enter_dead(p, PATH_SUCCESS);
657 return 1;
658 }
659
660 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
661 Path *p = ASSERT_PTR(PATH(u));
662
663 assert(f);
664 assert(fds);
665
666 (void) serialize_item(f, "state", path_state_to_string(p->state));
667 (void) serialize_item(f, "result", path_result_to_string(p->result));
668
669 LIST_FOREACH(spec, s, p->specs) {
670 const char *type;
671 _cleanup_free_ char *escaped = NULL;
672
673 escaped = cescape(s->path);
674 if (!escaped)
675 return log_oom();
676
677 assert_se(type = path_type_to_string(s->type));
678 (void) serialize_item_format(f, "path-spec", "%s %i %s",
679 type,
680 s->previous_exists,
681 escaped);
682 }
683
684 (void) serialize_ratelimit(f, "trigger-ratelimit", &p->trigger_limit);
685
686 return 0;
687 }
688
689 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
690 Path *p = ASSERT_PTR(PATH(u));
691
692 assert(key);
693 assert(value);
694 assert(fds);
695
696 if (streq(key, "state")) {
697 PathState state;
698
699 state = path_state_from_string(value);
700 if (state < 0)
701 log_unit_debug(u, "Failed to parse state value: %s", value);
702 else
703 p->deserialized_state = state;
704
705 } else if (streq(key, "result")) {
706 PathResult f;
707
708 f = path_result_from_string(value);
709 if (f < 0)
710 log_unit_debug(u, "Failed to parse result value: %s", value);
711 else if (f != PATH_SUCCESS)
712 p->result = f;
713
714 } else if (streq(key, "path-spec")) {
715 int previous_exists, skip = 0;
716 _cleanup_free_ char *type_str = NULL;
717
718 if (sscanf(value, "%ms %i %n", &type_str, &previous_exists, &skip) < 2)
719 log_unit_debug(u, "Failed to parse path-spec value: %s", value);
720 else {
721 _cleanup_free_ char *unescaped = NULL;
722 ssize_t l;
723 PathType type;
724
725 type = path_type_from_string(type_str);
726 if (type < 0) {
727 log_unit_warning(u, "Unknown path type \"%s\", ignoring.", type_str);
728 return 0;
729 }
730
731 l = cunescape(value+skip, 0, &unescaped);
732 if (l < 0) {
733 log_unit_warning_errno(u, l, "Failed to unescape serialize path: %m");
734 return 0;
735 }
736
737 LIST_FOREACH(spec, s, p->specs)
738 if (s->type == type &&
739 path_equal(s->path, unescaped)) {
740
741 s->previous_exists = previous_exists;
742 break;
743 }
744 }
745
746 } else if (streq(key, "trigger-ratelimit"))
747 deserialize_ratelimit(&p->trigger_limit, key, value);
748
749 else
750 log_unit_debug(u, "Unknown serialization key: %s", key);
751
752 return 0;
753 }
754
755 static UnitActiveState path_active_state(Unit *u) {
756 Path *p = ASSERT_PTR(PATH(u));
757
758 return state_translation_table[p->state];
759 }
760
761 static const char *path_sub_state_to_string(Unit *u) {
762 Path *p = ASSERT_PTR(PATH(u));
763
764 return path_state_to_string(p->state);
765 }
766
767 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
768 PathSpec *s = ASSERT_PTR(userdata), *found = NULL;
769 Path *p = ASSERT_PTR(PATH(s->unit));
770 int changed;
771
772 assert(fd >= 0);
773
774 if (!IN_SET(p->state, PATH_WAITING, PATH_RUNNING))
775 return 0;
776
777 LIST_FOREACH(spec, i, p->specs)
778 if (path_spec_owns_inotify_fd(i, fd)) {
779 found = i;
780 break;
781 }
782
783 if (!found) {
784 log_error("Got event on unknown fd.");
785 goto fail;
786 }
787
788 changed = path_spec_fd_event(found, revents);
789 if (changed < 0)
790 goto fail;
791
792 if (changed)
793 path_enter_running(p, found->path);
794 else
795 path_enter_waiting(p, false, false);
796
797 return 0;
798
799 fail:
800 path_enter_dead(p, PATH_FAILURE_RESOURCES);
801 return 0;
802 }
803
804 static void path_trigger_notify_impl(Unit *u, Unit *other, bool on_defer);
805
806 static int path_trigger_notify_on_defer(sd_event_source *s, void *userdata) {
807 Path *p = ASSERT_PTR(userdata);
808 Unit *trigger;
809
810 assert(s);
811
812 trigger = UNIT_TRIGGER(UNIT(p));
813 if (!trigger) {
814 log_unit_error(UNIT(p), "Unit to trigger vanished.");
815 path_enter_dead(p, PATH_FAILURE_RESOURCES);
816 return 0;
817 }
818
819 path_trigger_notify_impl(UNIT(p), trigger, /* on_defer = */ true);
820 return 0;
821 }
822
823 static void path_trigger_notify_impl(Unit *u, Unit *other, bool on_defer) {
824 Path *p = ASSERT_PTR(PATH(u));
825 int r;
826
827 assert(other);
828
829 /* Invoked whenever the unit we trigger changes state or gains or loses a job */
830
831 /* Filter out invocations with bogus state */
832 assert(UNIT_IS_LOAD_COMPLETE(other->load_state));
833
834 /* Don't propagate state changes from the triggered unit if we are already down */
835 if (!IN_SET(p->state, PATH_WAITING, PATH_RUNNING))
836 return;
837
838 /* Propagate start limit hit state */
839 if (other->start_limit_hit) {
840 path_enter_dead(p, PATH_FAILURE_UNIT_START_LIMIT_HIT);
841 return;
842 }
843
844 /* Don't propagate anything if there's still a job queued */
845 if (other->job)
846 return;
847
848 if (p->state == PATH_RUNNING &&
849 UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other))) {
850 if (!on_defer)
851 log_unit_debug(u, "Got notified about unit deactivation.");
852 } else if (p->state == PATH_WAITING &&
853 !UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other))) {
854 if (!on_defer)
855 log_unit_debug(u, "Got notified about unit activation.");
856 } else
857 return;
858
859 if (on_defer) {
860 path_enter_waiting(p, /* initial = */ false, /* from_trigger_notify = */ true);
861 return;
862 }
863
864 /* Do not call path_enter_waiting() directly from path_trigger_notify(), as this may be called by
865 * job_install() -> job_finish_and_invalidate() -> unit_trigger_notify(), and path_enter_waiting()
866 * may install another job and will trigger assertion in job_install().
867 * https://github.com/systemd/systemd/issues/24577#issuecomment-1522628906
868 * Hence, first setup defer event source here, and call path_enter_waiting() slightly later. */
869 if (p->trigger_notify_event_source) {
870 r = sd_event_source_set_enabled(p->trigger_notify_event_source, SD_EVENT_ONESHOT);
871 if (r < 0) {
872 log_unit_warning_errno(u, r, "Failed to enable event source for triggering notify: %m");
873 path_enter_dead(p, PATH_FAILURE_RESOURCES);
874 return;
875 }
876 } else {
877 r = sd_event_add_defer(u->manager->event, &p->trigger_notify_event_source, path_trigger_notify_on_defer, p);
878 if (r < 0) {
879 log_unit_warning_errno(u, r, "Failed to allocate event source for triggering notify: %m");
880 path_enter_dead(p, PATH_FAILURE_RESOURCES);
881 return;
882 }
883
884 (void) sd_event_source_set_description(p->trigger_notify_event_source, "path-trigger-notify");
885 }
886 }
887
888 static void path_trigger_notify(Unit *u, Unit *other) {
889 path_trigger_notify_impl(u, other, /* on_defer = */ false);
890 }
891
892 static void path_reset_failed(Unit *u) {
893 Path *p = ASSERT_PTR(PATH(u));
894
895 if (p->state == PATH_FAILED)
896 path_set_state(p, PATH_DEAD);
897
898 p->result = PATH_SUCCESS;
899 }
900
901 static int path_can_start(Unit *u) {
902 Path *p = ASSERT_PTR(PATH(u));
903 int r;
904
905 r = unit_test_start_limit(u);
906 if (r < 0) {
907 path_enter_dead(p, PATH_FAILURE_START_LIMIT_HIT);
908 return r;
909 }
910
911 return 1;
912 }
913
914 static void activation_details_path_done(ActivationDetails *details) {
915 ActivationDetailsPath *p = ASSERT_PTR(ACTIVATION_DETAILS_PATH(details));
916
917 p->trigger_path_filename = mfree(p->trigger_path_filename);
918 }
919
920 static void activation_details_path_serialize(ActivationDetails *details, FILE *f) {
921 ActivationDetailsPath *p = ASSERT_PTR(ACTIVATION_DETAILS_PATH(details));
922
923 assert(f);
924
925 if (p->trigger_path_filename)
926 (void) serialize_item(f, "activation-details-path-filename", p->trigger_path_filename);
927 }
928
929 static int activation_details_path_deserialize(const char *key, const char *value, ActivationDetails **details) {
930 int r;
931
932 assert(key);
933 assert(value);
934
935 if (!details || !*details)
936 return -EINVAL;
937
938 ActivationDetailsPath *p = ACTIVATION_DETAILS_PATH(*details);
939 if (!p)
940 return -EINVAL;
941
942 if (!streq(key, "activation-details-path-filename"))
943 return -EINVAL;
944
945 r = free_and_strdup(&p->trigger_path_filename, value);
946 if (r < 0)
947 return r;
948
949 return 0;
950 }
951
952 static int activation_details_path_append_env(ActivationDetails *details, char ***strv) {
953 ActivationDetailsPath *p = ASSERT_PTR(ACTIVATION_DETAILS_PATH(details));
954 char *s;
955 int r;
956
957 assert(strv);
958
959 if (isempty(p->trigger_path_filename))
960 return 0;
961
962 s = strjoin("TRIGGER_PATH=", p->trigger_path_filename);
963 if (!s)
964 return -ENOMEM;
965
966 r = strv_consume(strv, TAKE_PTR(s));
967 if (r < 0)
968 return r;
969
970 return 1; /* Return the number of variables added to the env block */
971 }
972
973 static int activation_details_path_append_pair(ActivationDetails *details, char ***strv) {
974 ActivationDetailsPath *p = ASSERT_PTR(ACTIVATION_DETAILS_PATH(details));
975 int r;
976
977 assert(strv);
978
979 if (isempty(p->trigger_path_filename))
980 return 0;
981
982 r = strv_extend_many(strv, "trigger_path", p->trigger_path_filename);
983 if (r < 0)
984 return r;
985
986 return 1; /* Return the number of pairs added to the env block */
987 }
988
989 static const char* const path_type_table[_PATH_TYPE_MAX] = {
990 [PATH_EXISTS] = "PathExists",
991 [PATH_EXISTS_GLOB] = "PathExistsGlob",
992 [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
993 [PATH_CHANGED] = "PathChanged",
994 [PATH_MODIFIED] = "PathModified",
995 };
996
997 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
998
999 static const char* const path_result_table[_PATH_RESULT_MAX] = {
1000 [PATH_SUCCESS] = "success",
1001 [PATH_FAILURE_RESOURCES] = "resources",
1002 [PATH_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
1003 [PATH_FAILURE_UNIT_START_LIMIT_HIT] = "unit-start-limit-hit",
1004 [PATH_FAILURE_TRIGGER_LIMIT_HIT] = "trigger-limit-hit",
1005 };
1006
1007 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
1008
1009 const UnitVTable path_vtable = {
1010 .object_size = sizeof(Path),
1011
1012 .sections =
1013 "Unit\0"
1014 "Path\0"
1015 "Install\0",
1016 .private_section = "Path",
1017
1018 .can_transient = true,
1019 .can_fail = true,
1020 .can_trigger = true,
1021
1022 .init = path_init,
1023 .done = path_done,
1024 .load = path_load,
1025
1026 .coldplug = path_coldplug,
1027
1028 .dump = path_dump,
1029
1030 .start = path_start,
1031 .stop = path_stop,
1032
1033 .serialize = path_serialize,
1034 .deserialize_item = path_deserialize_item,
1035
1036 .active_state = path_active_state,
1037 .sub_state_to_string = path_sub_state_to_string,
1038
1039 .trigger_notify = path_trigger_notify,
1040
1041 .reset_failed = path_reset_failed,
1042
1043 .bus_set_property = bus_path_set_property,
1044
1045 .can_start = path_can_start,
1046 };
1047
1048 const ActivationDetailsVTable activation_details_path_vtable = {
1049 .object_size = sizeof(ActivationDetailsPath),
1050
1051 .done = activation_details_path_done,
1052 .serialize = activation_details_path_serialize,
1053 .deserialize = activation_details_path_deserialize,
1054 .append_env = activation_details_path_append_env,
1055 .append_pair = activation_details_path_append_pair,
1056 };