]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/service.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
core: rework serialization
[thirdparty/systemd.git] / src / core / service.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <signal.h>
5 #include <unistd.h>
6
7 #include "sd-messages.h"
8
9 #include "alloc-util.h"
10 #include "async.h"
11 #include "bus-error.h"
12 #include "bus-kernel.h"
13 #include "bus-util.h"
14 #include "dbus-service.h"
15 #include "def.h"
16 #include "env-util.h"
17 #include "escape.h"
18 #include "exit-status.h"
19 #include "fd-util.h"
20 #include "fileio.h"
21 #include "format-util.h"
22 #include "fs-util.h"
23 #include "load-dropin.h"
24 #include "load-fragment.h"
25 #include "log.h"
26 #include "manager.h"
27 #include "parse-util.h"
28 #include "path-util.h"
29 #include "process-util.h"
30 #include "serialize.h"
31 #include "service.h"
32 #include "signal-util.h"
33 #include "special.h"
34 #include "stdio-util.h"
35 #include "string-table.h"
36 #include "string-util.h"
37 #include "strv.h"
38 #include "unit-name.h"
39 #include "unit.h"
40 #include "utf8.h"
41 #include "util.h"
42
43 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
44 [SERVICE_DEAD] = UNIT_INACTIVE,
45 [SERVICE_START_PRE] = UNIT_ACTIVATING,
46 [SERVICE_START] = UNIT_ACTIVATING,
47 [SERVICE_START_POST] = UNIT_ACTIVATING,
48 [SERVICE_RUNNING] = UNIT_ACTIVE,
49 [SERVICE_EXITED] = UNIT_ACTIVE,
50 [SERVICE_RELOAD] = UNIT_RELOADING,
51 [SERVICE_STOP] = UNIT_DEACTIVATING,
52 [SERVICE_STOP_WATCHDOG] = UNIT_DEACTIVATING,
53 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
54 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
55 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
56 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
57 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
58 [SERVICE_FAILED] = UNIT_FAILED,
59 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
60 };
61
62 /* For Type=idle we never want to delay any other jobs, hence we
63 * consider idle jobs active as soon as we start working on them */
64 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
65 [SERVICE_DEAD] = UNIT_INACTIVE,
66 [SERVICE_START_PRE] = UNIT_ACTIVE,
67 [SERVICE_START] = UNIT_ACTIVE,
68 [SERVICE_START_POST] = UNIT_ACTIVE,
69 [SERVICE_RUNNING] = UNIT_ACTIVE,
70 [SERVICE_EXITED] = UNIT_ACTIVE,
71 [SERVICE_RELOAD] = UNIT_RELOADING,
72 [SERVICE_STOP] = UNIT_DEACTIVATING,
73 [SERVICE_STOP_WATCHDOG] = UNIT_DEACTIVATING,
74 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
75 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
76 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
77 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
78 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
79 [SERVICE_FAILED] = UNIT_FAILED,
80 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
81 };
82
83 static int service_dispatch_inotify_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
84 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
85 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
86 static int service_dispatch_exec_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
87
88 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
89 static void service_enter_reload_by_notify(Service *s);
90
91 static void service_init(Unit *u) {
92 Service *s = SERVICE(u);
93
94 assert(u);
95 assert(u->load_state == UNIT_STUB);
96
97 s->timeout_start_usec = u->manager->default_timeout_start_usec;
98 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
99 s->restart_usec = u->manager->default_restart_usec;
100 s->runtime_max_usec = USEC_INFINITY;
101 s->type = _SERVICE_TYPE_INVALID;
102 s->socket_fd = -1;
103 s->stdin_fd = s->stdout_fd = s->stderr_fd = -1;
104 s->guess_main_pid = true;
105
106 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
107
108 s->exec_context.keyring_mode = MANAGER_IS_SYSTEM(u->manager) ?
109 EXEC_KEYRING_PRIVATE : EXEC_KEYRING_INHERIT;
110 }
111
112 static void service_unwatch_control_pid(Service *s) {
113 assert(s);
114
115 if (s->control_pid <= 0)
116 return;
117
118 unit_unwatch_pid(UNIT(s), s->control_pid);
119 s->control_pid = 0;
120 }
121
122 static void service_unwatch_main_pid(Service *s) {
123 assert(s);
124
125 if (s->main_pid <= 0)
126 return;
127
128 unit_unwatch_pid(UNIT(s), s->main_pid);
129 s->main_pid = 0;
130 }
131
132 static void service_unwatch_pid_file(Service *s) {
133 if (!s->pid_file_pathspec)
134 return;
135
136 log_unit_debug(UNIT(s), "Stopping watch for PID file %s", s->pid_file_pathspec->path);
137 path_spec_unwatch(s->pid_file_pathspec);
138 path_spec_done(s->pid_file_pathspec);
139 s->pid_file_pathspec = mfree(s->pid_file_pathspec);
140 }
141
142 static int service_set_main_pid(Service *s, pid_t pid) {
143 pid_t ppid;
144
145 assert(s);
146
147 if (pid <= 1)
148 return -EINVAL;
149
150 if (pid == getpid_cached())
151 return -EINVAL;
152
153 if (s->main_pid == pid && s->main_pid_known)
154 return 0;
155
156 if (s->main_pid != pid) {
157 service_unwatch_main_pid(s);
158 exec_status_start(&s->main_exec_status, pid);
159 }
160
161 s->main_pid = pid;
162 s->main_pid_known = true;
163
164 if (get_process_ppid(pid, &ppid) >= 0 && ppid != getpid_cached()) {
165 log_unit_warning(UNIT(s), "Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", pid);
166 s->main_pid_alien = true;
167 } else
168 s->main_pid_alien = false;
169
170 return 0;
171 }
172
173 void service_close_socket_fd(Service *s) {
174 assert(s);
175
176 /* Undo the effect of service_set_socket_fd(). */
177
178 s->socket_fd = asynchronous_close(s->socket_fd);
179
180 if (UNIT_ISSET(s->accept_socket)) {
181 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
182 unit_ref_unset(&s->accept_socket);
183 }
184 }
185
186 static void service_stop_watchdog(Service *s) {
187 assert(s);
188
189 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
190 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
191 }
192
193 static usec_t service_get_watchdog_usec(Service *s) {
194 assert(s);
195
196 if (s->watchdog_override_enable)
197 return s->watchdog_override_usec;
198 else
199 return s->watchdog_usec;
200 }
201
202 static void service_start_watchdog(Service *s) {
203 int r;
204 usec_t watchdog_usec;
205
206 assert(s);
207
208 watchdog_usec = service_get_watchdog_usec(s);
209 if (IN_SET(watchdog_usec, 0, USEC_INFINITY))
210 return;
211
212 if (s->watchdog_event_source) {
213 r = sd_event_source_set_time(s->watchdog_event_source, usec_add(s->watchdog_timestamp.monotonic, watchdog_usec));
214 if (r < 0) {
215 log_unit_warning_errno(UNIT(s), r, "Failed to reset watchdog timer: %m");
216 return;
217 }
218
219 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
220 } else {
221 r = sd_event_add_time(
222 UNIT(s)->manager->event,
223 &s->watchdog_event_source,
224 CLOCK_MONOTONIC,
225 usec_add(s->watchdog_timestamp.monotonic, watchdog_usec), 0,
226 service_dispatch_watchdog, s);
227 if (r < 0) {
228 log_unit_warning_errno(UNIT(s), r, "Failed to add watchdog timer: %m");
229 return;
230 }
231
232 (void) sd_event_source_set_description(s->watchdog_event_source, "service-watchdog");
233
234 /* Let's process everything else which might be a sign
235 * of living before we consider a service died. */
236 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
237 }
238
239 if (r < 0)
240 log_unit_warning_errno(UNIT(s), r, "Failed to install watchdog timer: %m");
241 }
242
243 static void service_extend_timeout(Service *s, usec_t extend_timeout_usec) {
244 assert(s);
245
246 if (s->timer_event_source) {
247 uint64_t current = 0, extended = 0;
248 int r;
249
250 if (IN_SET(extend_timeout_usec, 0, USEC_INFINITY))
251 return;
252
253 extended = usec_add(now(CLOCK_MONOTONIC), extend_timeout_usec);
254
255 r = sd_event_source_get_time(s->timer_event_source, &current);
256 if (r < 0)
257 log_unit_error_errno(UNIT(s), r, "Failed to retrieve timeout timer: %m");
258 else if (extended > current) {
259 r = sd_event_source_set_time(s->timer_event_source, extended);
260 if (r < 0)
261 log_unit_warning_errno(UNIT(s), r, "Failed to set timeout timer: %m");
262 }
263
264 if (s->watchdog_event_source) {
265 /* extend watchdog if necessary. We've asked for an extended timeout so we
266 * shouldn't expect a watchdog timeout in the interval in between */
267 r = sd_event_source_get_time(s->watchdog_event_source, &current);
268 if (r < 0) {
269 log_unit_error_errno(UNIT(s), r, "Failed to retrieve watchdog timer: %m");
270 return;
271 }
272
273 if (extended > current) {
274 r = sd_event_source_set_time(s->watchdog_event_source, extended);
275 if (r < 0)
276 log_unit_warning_errno(UNIT(s), r, "Failed to set watchdog timer: %m");
277 }
278 }
279 }
280 }
281
282 static void service_reset_watchdog(Service *s) {
283 assert(s);
284
285 dual_timestamp_get(&s->watchdog_timestamp);
286 service_start_watchdog(s);
287 }
288
289 static void service_reset_watchdog_timeout(Service *s, usec_t watchdog_override_usec) {
290 assert(s);
291
292 s->watchdog_override_enable = true;
293 s->watchdog_override_usec = watchdog_override_usec;
294 service_reset_watchdog(s);
295
296 log_unit_debug(UNIT(s), "watchdog_usec="USEC_FMT, s->watchdog_usec);
297 log_unit_debug(UNIT(s), "watchdog_override_usec="USEC_FMT, s->watchdog_override_usec);
298 }
299
300 static void service_fd_store_unlink(ServiceFDStore *fs) {
301
302 if (!fs)
303 return;
304
305 if (fs->service) {
306 assert(fs->service->n_fd_store > 0);
307 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
308 fs->service->n_fd_store--;
309 }
310
311 if (fs->event_source) {
312 sd_event_source_set_enabled(fs->event_source, SD_EVENT_OFF);
313 sd_event_source_unref(fs->event_source);
314 }
315
316 free(fs->fdname);
317 safe_close(fs->fd);
318 free(fs);
319 }
320
321 static void service_release_fd_store(Service *s) {
322 assert(s);
323
324 if (s->n_keep_fd_store > 0)
325 return;
326
327 log_unit_debug(UNIT(s), "Releasing all stored fds");
328 while (s->fd_store)
329 service_fd_store_unlink(s->fd_store);
330
331 assert(s->n_fd_store == 0);
332 }
333
334 static void service_release_resources(Unit *u) {
335 Service *s = SERVICE(u);
336
337 assert(s);
338
339 if (!s->fd_store && s->stdin_fd < 0 && s->stdout_fd < 0 && s->stderr_fd < 0)
340 return;
341
342 log_unit_debug(u, "Releasing resources.");
343
344 s->stdin_fd = safe_close(s->stdin_fd);
345 s->stdout_fd = safe_close(s->stdout_fd);
346 s->stderr_fd = safe_close(s->stderr_fd);
347
348 service_release_fd_store(s);
349 }
350
351 static void service_done(Unit *u) {
352 Service *s = SERVICE(u);
353
354 assert(s);
355
356 s->pid_file = mfree(s->pid_file);
357 s->status_text = mfree(s->status_text);
358
359 s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
360 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
361 s->control_command = NULL;
362 s->main_command = NULL;
363
364 dynamic_creds_unref(&s->dynamic_creds);
365
366 exit_status_set_free(&s->restart_prevent_status);
367 exit_status_set_free(&s->restart_force_status);
368 exit_status_set_free(&s->success_status);
369
370 /* This will leak a process, but at least no memory or any of
371 * our resources */
372 service_unwatch_main_pid(s);
373 service_unwatch_control_pid(s);
374 service_unwatch_pid_file(s);
375
376 if (s->bus_name) {
377 unit_unwatch_bus_name(u, s->bus_name);
378 s->bus_name = mfree(s->bus_name);
379 }
380
381 s->bus_name_owner = mfree(s->bus_name_owner);
382
383 s->usb_function_descriptors = mfree(s->usb_function_descriptors);
384 s->usb_function_strings = mfree(s->usb_function_strings);
385
386 service_close_socket_fd(s);
387 s->peer = socket_peer_unref(s->peer);
388
389 unit_ref_unset(&s->accept_socket);
390
391 service_stop_watchdog(s);
392
393 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
394 s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
395
396 service_release_resources(u);
397 }
398
399 static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
400 ServiceFDStore *fs = userdata;
401
402 assert(e);
403 assert(fs);
404
405 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
406 log_unit_debug(UNIT(fs->service),
407 "Received %s on stored fd %d (%s), closing.",
408 revents & EPOLLERR ? "EPOLLERR" : "EPOLLHUP",
409 fs->fd, strna(fs->fdname));
410 service_fd_store_unlink(fs);
411 return 0;
412 }
413
414 static int service_add_fd_store(Service *s, int fd, const char *name) {
415 ServiceFDStore *fs;
416 int r;
417
418 /* fd is always consumed if we return >= 0 */
419
420 assert(s);
421 assert(fd >= 0);
422
423 if (s->n_fd_store >= s->n_fd_store_max)
424 return -EXFULL; /* Our store is full.
425 * Use this errno rather than E[NM]FILE to distinguish from
426 * the case where systemd itself hits the file limit. */
427
428 LIST_FOREACH(fd_store, fs, s->fd_store) {
429 r = same_fd(fs->fd, fd);
430 if (r < 0)
431 return r;
432 if (r > 0) {
433 safe_close(fd);
434 return 0; /* fd already included */
435 }
436 }
437
438 fs = new0(ServiceFDStore, 1);
439 if (!fs)
440 return -ENOMEM;
441
442 fs->fd = fd;
443 fs->service = s;
444 fs->fdname = strdup(name ?: "stored");
445 if (!fs->fdname) {
446 free(fs);
447 return -ENOMEM;
448 }
449
450 r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
451 if (r < 0 && r != -EPERM) { /* EPERM indicates fds that aren't pollable, which is OK */
452 free(fs->fdname);
453 free(fs);
454 return r;
455 } else if (r >= 0)
456 (void) sd_event_source_set_description(fs->event_source, "service-fd-store");
457
458 LIST_PREPEND(fd_store, s->fd_store, fs);
459 s->n_fd_store++;
460
461 return 1; /* fd newly stored */
462 }
463
464 static int service_add_fd_store_set(Service *s, FDSet *fds, const char *name) {
465 int r;
466
467 assert(s);
468
469 while (fdset_size(fds) > 0) {
470 _cleanup_close_ int fd = -1;
471
472 fd = fdset_steal_first(fds);
473 if (fd < 0)
474 break;
475
476 r = service_add_fd_store(s, fd, name);
477 if (r == -EXFULL)
478 return log_unit_warning_errno(UNIT(s), r,
479 "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
480 s->n_fd_store_max);
481 if (r < 0)
482 return log_unit_error_errno(UNIT(s), r, "Failed to add fd to store: %m");
483 if (r > 0)
484 log_unit_debug(UNIT(s), "Added fd %u (%s) to fd store.", fd, strna(name));
485 fd = -1;
486 }
487
488 return 0;
489 }
490
491 static void service_remove_fd_store(Service *s, const char *name) {
492 ServiceFDStore *fs, *n;
493
494 assert(s);
495 assert(name);
496
497 LIST_FOREACH_SAFE(fd_store, fs, n, s->fd_store) {
498 if (!streq(fs->fdname, name))
499 continue;
500
501 log_unit_debug(UNIT(s), "Got explicit request to remove fd %i (%s), closing.", fs->fd, name);
502 service_fd_store_unlink(fs);
503 }
504 }
505
506 static int service_arm_timer(Service *s, usec_t usec) {
507 int r;
508
509 assert(s);
510
511 if (s->timer_event_source) {
512 r = sd_event_source_set_time(s->timer_event_source, usec);
513 if (r < 0)
514 return r;
515
516 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
517 }
518
519 if (usec == USEC_INFINITY)
520 return 0;
521
522 r = sd_event_add_time(
523 UNIT(s)->manager->event,
524 &s->timer_event_source,
525 CLOCK_MONOTONIC,
526 usec, 0,
527 service_dispatch_timer, s);
528 if (r < 0)
529 return r;
530
531 (void) sd_event_source_set_description(s->timer_event_source, "service-timer");
532
533 return 0;
534 }
535
536 static int service_verify(Service *s) {
537 assert(s);
538
539 if (UNIT(s)->load_state != UNIT_LOADED)
540 return 0;
541
542 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]
543 && UNIT(s)->success_action == EMERGENCY_ACTION_NONE) {
544 /* FailureAction= only makes sense if one of the start or stop commands is specified.
545 * SuccessAction= will be executed unconditionally if no commands are specified. Hence,
546 * either a command or SuccessAction= are required. */
547
548 log_unit_error(UNIT(s), "Service has no ExecStart=, ExecStop=, or SuccessAction=. Refusing.");
549 return -ENOEXEC;
550 }
551
552 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
553 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
554 return -ENOEXEC;
555 }
556
557 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START] && UNIT(s)->success_action == EMERGENCY_ACTION_NONE) {
558 log_unit_error(UNIT(s), "Service has no ExecStart= and no SuccessAction= settings and does not have RemainAfterExit=yes set. Refusing.");
559 return -ENOEXEC;
560 }
561
562 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
563 log_unit_error(UNIT(s), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
564 return -ENOEXEC;
565 }
566
567 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
568 log_unit_error(UNIT(s), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
569 return -ENOEXEC;
570 }
571
572 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
573 log_unit_error(UNIT(s), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
574 return -ENOEXEC;
575 }
576
577 if (s->type == SERVICE_DBUS && !s->bus_name) {
578 log_unit_error(UNIT(s), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
579 return -ENOEXEC;
580 }
581
582 if (s->bus_name && s->type != SERVICE_DBUS)
583 log_unit_warning(UNIT(s), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
584
585 if (s->exec_context.pam_name && !IN_SET(s->kill_context.kill_mode, KILL_CONTROL_GROUP, KILL_MIXED)) {
586 log_unit_error(UNIT(s), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
587 return -ENOEXEC;
588 }
589
590 if (s->usb_function_descriptors && !s->usb_function_strings)
591 log_unit_warning(UNIT(s), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
592
593 if (!s->usb_function_descriptors && s->usb_function_strings)
594 log_unit_warning(UNIT(s), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
595
596 if (s->runtime_max_usec != USEC_INFINITY && s->type == SERVICE_ONESHOT)
597 log_unit_warning(UNIT(s), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
598
599 return 0;
600 }
601
602 static int service_add_default_dependencies(Service *s) {
603 int r;
604
605 assert(s);
606
607 if (!UNIT(s)->default_dependencies)
608 return 0;
609
610 /* Add a number of automatic dependencies useful for the
611 * majority of services. */
612
613 if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
614 /* First, pull in the really early boot stuff, and
615 * require it, so that we fail if we can't acquire
616 * it. */
617
618 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
619 if (r < 0)
620 return r;
621 } else {
622
623 /* In the --user instance there's no sysinit.target,
624 * in that case require basic.target instead. */
625
626 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_BASIC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
627 if (r < 0)
628 return r;
629 }
630
631 /* Second, if the rest of the base system is in the same
632 * transaction, order us after it, but do not pull it in or
633 * even require it. */
634 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_BASIC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
635 if (r < 0)
636 return r;
637
638 /* Third, add us in for normal shutdown. */
639 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
640 }
641
642 static void service_fix_output(Service *s) {
643 assert(s);
644
645 /* If nothing has been explicitly configured, patch default output in. If input is socket/tty we avoid this
646 * however, since in that case we want output to default to the same place as we read input from. */
647
648 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
649 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
650 s->exec_context.std_input == EXEC_INPUT_NULL)
651 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
652
653 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
654 s->exec_context.std_input == EXEC_INPUT_NULL)
655 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
656
657 if (s->exec_context.std_input == EXEC_INPUT_NULL &&
658 s->exec_context.stdin_data_size > 0)
659 s->exec_context.std_input = EXEC_INPUT_DATA;
660 }
661
662 static int service_setup_bus_name(Service *s) {
663 int r;
664
665 assert(s);
666
667 if (!s->bus_name)
668 return 0;
669
670 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, true, UNIT_DEPENDENCY_FILE);
671 if (r < 0)
672 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
673
674 /* We always want to be ordered against dbus.socket if both are in the transaction. */
675 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_DBUS_SOCKET, true, UNIT_DEPENDENCY_FILE);
676 if (r < 0)
677 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
678
679 r = unit_watch_bus_name(UNIT(s), s->bus_name);
680 if (r == -EEXIST)
681 return log_unit_error_errno(UNIT(s), r, "Two services allocated for the same bus name %s, refusing operation.", s->bus_name);
682 if (r < 0)
683 return log_unit_error_errno(UNIT(s), r, "Cannot watch bus name %s: %m", s->bus_name);
684
685 return 0;
686 }
687
688 static int service_add_extras(Service *s) {
689 int r;
690
691 assert(s);
692
693 if (s->type == _SERVICE_TYPE_INVALID) {
694 /* Figure out a type automatically */
695 if (s->bus_name)
696 s->type = SERVICE_DBUS;
697 else if (s->exec_command[SERVICE_EXEC_START])
698 s->type = SERVICE_SIMPLE;
699 else
700 s->type = SERVICE_ONESHOT;
701 }
702
703 /* Oneshot services have disabled start timeout by default */
704 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
705 s->timeout_start_usec = USEC_INFINITY;
706
707 service_fix_output(s);
708
709 r = unit_patch_contexts(UNIT(s));
710 if (r < 0)
711 return r;
712
713 r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
714 if (r < 0)
715 return r;
716
717 r = unit_set_default_slice(UNIT(s));
718 if (r < 0)
719 return r;
720
721 /* If the service needs the notify socket, let's enable it automatically. */
722 if (s->notify_access == NOTIFY_NONE &&
723 (s->type == SERVICE_NOTIFY || s->watchdog_usec > 0 || s->n_fd_store_max > 0))
724 s->notify_access = NOTIFY_MAIN;
725
726 r = service_add_default_dependencies(s);
727 if (r < 0)
728 return r;
729
730 r = service_setup_bus_name(s);
731 if (r < 0)
732 return r;
733
734 return 0;
735 }
736
737 static int service_load(Unit *u) {
738 Service *s = SERVICE(u);
739 int r;
740
741 assert(s);
742
743 /* Load a .service file */
744 r = unit_load_fragment(u);
745 if (r < 0)
746 return r;
747
748 /* Still nothing found? Then let's give up */
749 if (u->load_state == UNIT_STUB)
750 return -ENOENT;
751
752 /* This is a new unit? Then let's add in some extras */
753 if (u->load_state == UNIT_LOADED) {
754
755 /* We were able to load something, then let's add in
756 * the dropin directories. */
757 r = unit_load_dropin(u);
758 if (r < 0)
759 return r;
760
761 /* This is a new unit? Then let's add in some
762 * extras */
763 r = service_add_extras(s);
764 if (r < 0)
765 return r;
766 }
767
768 return service_verify(s);
769 }
770
771 static void service_dump(Unit *u, FILE *f, const char *prefix) {
772 char buf_restart[FORMAT_TIMESPAN_MAX], buf_start[FORMAT_TIMESPAN_MAX], buf_stop[FORMAT_TIMESPAN_MAX];
773 char buf_runtime[FORMAT_TIMESPAN_MAX], buf_watchdog[FORMAT_TIMESPAN_MAX];
774 ServiceExecCommand c;
775 Service *s = SERVICE(u);
776 const char *prefix2;
777
778 assert(s);
779
780 prefix = strempty(prefix);
781 prefix2 = strjoina(prefix, "\t");
782
783 fprintf(f,
784 "%sService State: %s\n"
785 "%sResult: %s\n"
786 "%sReload Result: %s\n"
787 "%sPermissionsStartOnly: %s\n"
788 "%sRootDirectoryStartOnly: %s\n"
789 "%sRemainAfterExit: %s\n"
790 "%sGuessMainPID: %s\n"
791 "%sType: %s\n"
792 "%sRestart: %s\n"
793 "%sNotifyAccess: %s\n"
794 "%sNotifyState: %s\n",
795 prefix, service_state_to_string(s->state),
796 prefix, service_result_to_string(s->result),
797 prefix, service_result_to_string(s->reload_result),
798 prefix, yes_no(s->permissions_start_only),
799 prefix, yes_no(s->root_directory_start_only),
800 prefix, yes_no(s->remain_after_exit),
801 prefix, yes_no(s->guess_main_pid),
802 prefix, service_type_to_string(s->type),
803 prefix, service_restart_to_string(s->restart),
804 prefix, notify_access_to_string(s->notify_access),
805 prefix, notify_state_to_string(s->notify_state));
806
807 if (s->control_pid > 0)
808 fprintf(f,
809 "%sControl PID: "PID_FMT"\n",
810 prefix, s->control_pid);
811
812 if (s->main_pid > 0)
813 fprintf(f,
814 "%sMain PID: "PID_FMT"\n"
815 "%sMain PID Known: %s\n"
816 "%sMain PID Alien: %s\n",
817 prefix, s->main_pid,
818 prefix, yes_no(s->main_pid_known),
819 prefix, yes_no(s->main_pid_alien));
820
821 if (s->pid_file)
822 fprintf(f,
823 "%sPIDFile: %s\n",
824 prefix, s->pid_file);
825
826 if (s->bus_name)
827 fprintf(f,
828 "%sBusName: %s\n"
829 "%sBus Name Good: %s\n",
830 prefix, s->bus_name,
831 prefix, yes_no(s->bus_name_good));
832
833 if (UNIT_ISSET(s->accept_socket))
834 fprintf(f,
835 "%sAccept Socket: %s\n",
836 prefix, UNIT_DEREF(s->accept_socket)->id);
837
838 fprintf(f,
839 "%sRestartSec: %s\n"
840 "%sTimeoutStartSec: %s\n"
841 "%sTimeoutStopSec: %s\n"
842 "%sRuntimeMaxSec: %s\n"
843 "%sWatchdogSec: %s\n",
844 prefix, format_timespan(buf_restart, sizeof(buf_restart), s->restart_usec, USEC_PER_SEC),
845 prefix, format_timespan(buf_start, sizeof(buf_start), s->timeout_start_usec, USEC_PER_SEC),
846 prefix, format_timespan(buf_stop, sizeof(buf_stop), s->timeout_stop_usec, USEC_PER_SEC),
847 prefix, format_timespan(buf_runtime, sizeof(buf_runtime), s->runtime_max_usec, USEC_PER_SEC),
848 prefix, format_timespan(buf_watchdog, sizeof(buf_watchdog), s->watchdog_usec, USEC_PER_SEC));
849
850 kill_context_dump(&s->kill_context, f, prefix);
851 exec_context_dump(&s->exec_context, f, prefix);
852
853 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
854
855 if (!s->exec_command[c])
856 continue;
857
858 fprintf(f, "%s-> %s:\n",
859 prefix, service_exec_command_to_string(c));
860
861 exec_command_dump_list(s->exec_command[c], f, prefix2);
862 }
863
864 if (s->status_text)
865 fprintf(f, "%sStatus Text: %s\n",
866 prefix, s->status_text);
867
868 if (s->n_fd_store_max > 0)
869 fprintf(f,
870 "%sFile Descriptor Store Max: %u\n"
871 "%sFile Descriptor Store Current: %zu\n",
872 prefix, s->n_fd_store_max,
873 prefix, s->n_fd_store);
874
875 cgroup_context_dump(&s->cgroup_context, f, prefix);
876 }
877
878 static int service_is_suitable_main_pid(Service *s, pid_t pid, int prio) {
879 Unit *owner;
880
881 assert(s);
882 assert(pid_is_valid(pid));
883
884 /* Checks whether the specified PID is suitable as main PID for this service. returns negative if not, 0 if the
885 * PID is questionnable but should be accepted if the source of configuration is trusted. > 0 if the PID is
886 * good */
887
888 if (pid == getpid_cached() || pid == 1) {
889 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the manager, refusing.", pid);
890 return -EPERM;
891 }
892
893 if (pid == s->control_pid) {
894 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the control process, refusing.", pid);
895 return -EPERM;
896 }
897
898 if (!pid_is_alive(pid)) {
899 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" does not exist or is a zombie.", pid);
900 return -ESRCH;
901 }
902
903 owner = manager_get_unit_by_pid(UNIT(s)->manager, pid);
904 if (owner == UNIT(s)) {
905 log_unit_debug(UNIT(s), "New main PID "PID_FMT" belongs to service, we are happy.", pid);
906 return 1; /* Yay, it's definitely a good PID */
907 }
908
909 return 0; /* Hmm it's a suspicious PID, let's accept it if configuration source is trusted */
910 }
911
912 static int service_load_pid_file(Service *s, bool may_warn) {
913 char procfs[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
914 bool questionable_pid_file = false;
915 _cleanup_free_ char *k = NULL;
916 _cleanup_close_ int fd = -1;
917 int r, prio;
918 pid_t pid;
919
920 assert(s);
921
922 if (!s->pid_file)
923 return -ENOENT;
924
925 prio = may_warn ? LOG_INFO : LOG_DEBUG;
926
927 fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN|CHASE_SAFE, NULL);
928 if (fd == -EPERM) {
929 log_unit_full(UNIT(s), LOG_DEBUG, fd, "Permission denied while opening PID file or potentially unsafe symlink chain, will now retry with relaxed checks: %s", s->pid_file);
930
931 questionable_pid_file = true;
932
933 fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN, NULL);
934 }
935 if (fd < 0)
936 return log_unit_full(UNIT(s), prio, fd, "Can't open PID file %s (yet?) after %s: %m", s->pid_file, service_state_to_string(s->state));
937
938 /* Let's read the PID file now that we chased it down. But we need to convert the O_PATH fd chase_symlinks() returned us into a proper fd first. */
939 xsprintf(procfs, "/proc/self/fd/%i", fd);
940 r = read_one_line_file(procfs, &k);
941 if (r < 0)
942 return log_unit_error_errno(UNIT(s), r, "Can't convert PID files %s O_PATH file descriptor to proper file descriptor: %m", s->pid_file);
943
944 r = parse_pid(k, &pid);
945 if (r < 0)
946 return log_unit_full(UNIT(s), prio, r, "Failed to parse PID from file %s: %m", s->pid_file);
947
948 if (s->main_pid_known && pid == s->main_pid)
949 return 0;
950
951 r = service_is_suitable_main_pid(s, pid, prio);
952 if (r < 0)
953 return r;
954 if (r == 0) {
955 struct stat st;
956
957 if (questionable_pid_file) {
958 log_unit_error(UNIT(s), "Refusing to accept PID outside of service control group, acquired through unsafe symlink chain: %s", s->pid_file);
959 return -EPERM;
960 }
961
962 /* Hmm, it's not clear if the new main PID is safe. Let's allow this if the PID file is owned by root */
963
964 if (fstat(fd, &st) < 0)
965 return log_unit_error_errno(UNIT(s), errno, "Failed to fstat() PID file O_PATH fd: %m");
966
967 if (st.st_uid != 0) {
968 log_unit_error(UNIT(s), "New main PID "PID_FMT" does not belong to service, and PID file is not owned by root. Refusing.", pid);
969 return -EPERM;
970 }
971
972 log_unit_debug(UNIT(s), "New main PID "PID_FMT" does not belong to service, but we'll accept it since PID file is owned by root.", pid);
973 }
974
975 if (s->main_pid_known) {
976 log_unit_debug(UNIT(s), "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
977
978 service_unwatch_main_pid(s);
979 s->main_pid_known = false;
980 } else
981 log_unit_debug(UNIT(s), "Main PID loaded: "PID_FMT, pid);
982
983 r = service_set_main_pid(s, pid);
984 if (r < 0)
985 return r;
986
987 r = unit_watch_pid(UNIT(s), pid);
988 if (r < 0) /* FIXME: we need to do something here */
989 return log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" for service: %m", pid);
990
991 return 1;
992 }
993
994 static void service_search_main_pid(Service *s) {
995 pid_t pid = 0;
996 int r;
997
998 assert(s);
999
1000 /* If we know it anyway, don't ever fallback to unreliable
1001 * heuristics */
1002 if (s->main_pid_known)
1003 return;
1004
1005 if (!s->guess_main_pid)
1006 return;
1007
1008 assert(s->main_pid <= 0);
1009
1010 if (unit_search_main_pid(UNIT(s), &pid) < 0)
1011 return;
1012
1013 log_unit_debug(UNIT(s), "Main PID guessed: "PID_FMT, pid);
1014 if (service_set_main_pid(s, pid) < 0)
1015 return;
1016
1017 r = unit_watch_pid(UNIT(s), pid);
1018 if (r < 0)
1019 /* FIXME: we need to do something here */
1020 log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" from: %m", pid);
1021 }
1022
1023 static void service_set_state(Service *s, ServiceState state) {
1024 ServiceState old_state;
1025 const UnitActiveState *table;
1026
1027 assert(s);
1028
1029 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1030
1031 old_state = s->state;
1032 s->state = state;
1033
1034 service_unwatch_pid_file(s);
1035
1036 if (!IN_SET(state,
1037 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1038 SERVICE_RUNNING,
1039 SERVICE_RELOAD,
1040 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1041 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1042 SERVICE_AUTO_RESTART))
1043 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1044
1045 if (!IN_SET(state,
1046 SERVICE_START, SERVICE_START_POST,
1047 SERVICE_RUNNING, SERVICE_RELOAD,
1048 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1049 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1050 service_unwatch_main_pid(s);
1051 s->main_command = NULL;
1052 }
1053
1054 if (!IN_SET(state,
1055 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1056 SERVICE_RELOAD,
1057 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1058 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1059 service_unwatch_control_pid(s);
1060 s->control_command = NULL;
1061 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1062 }
1063
1064 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
1065 unit_unwatch_all_pids(UNIT(s));
1066 unit_dequeue_rewatch_pids(UNIT(s));
1067 }
1068
1069 if (!IN_SET(state,
1070 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1071 SERVICE_RUNNING, SERVICE_RELOAD,
1072 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1073 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1074 !(state == SERVICE_DEAD && UNIT(s)->job))
1075 service_close_socket_fd(s);
1076
1077 if (state != SERVICE_START)
1078 s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
1079
1080 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1081 service_stop_watchdog(s);
1082
1083 /* For the inactive states unit_notify() will trim the cgroup,
1084 * but for exit we have to do that ourselves... */
1085 if (state == SERVICE_EXITED && !MANAGER_IS_RELOADING(UNIT(s)->manager))
1086 unit_prune_cgroup(UNIT(s));
1087
1088 if (old_state != state)
1089 log_unit_debug(UNIT(s), "Changed %s -> %s", service_state_to_string(old_state), service_state_to_string(state));
1090
1091 unit_notify(UNIT(s), table[old_state], table[state],
1092 (s->reload_result == SERVICE_SUCCESS ? 0 : UNIT_NOTIFY_RELOAD_FAILURE) |
1093 (s->will_auto_restart ? UNIT_NOTIFY_WILL_AUTO_RESTART : 0));
1094 }
1095
1096 static usec_t service_coldplug_timeout(Service *s) {
1097 assert(s);
1098
1099 switch (s->deserialized_state) {
1100
1101 case SERVICE_START_PRE:
1102 case SERVICE_START:
1103 case SERVICE_START_POST:
1104 case SERVICE_RELOAD:
1105 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_start_usec);
1106
1107 case SERVICE_RUNNING:
1108 return usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec);
1109
1110 case SERVICE_STOP:
1111 case SERVICE_STOP_WATCHDOG:
1112 case SERVICE_STOP_SIGTERM:
1113 case SERVICE_STOP_SIGKILL:
1114 case SERVICE_STOP_POST:
1115 case SERVICE_FINAL_SIGTERM:
1116 case SERVICE_FINAL_SIGKILL:
1117 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_stop_usec);
1118
1119 case SERVICE_AUTO_RESTART:
1120 return usec_add(UNIT(s)->inactive_enter_timestamp.monotonic, s->restart_usec);
1121
1122 default:
1123 return USEC_INFINITY;
1124 }
1125 }
1126
1127 static int service_coldplug(Unit *u) {
1128 Service *s = SERVICE(u);
1129 int r;
1130
1131 assert(s);
1132 assert(s->state == SERVICE_DEAD);
1133
1134 if (s->deserialized_state == s->state)
1135 return 0;
1136
1137 r = service_arm_timer(s, service_coldplug_timeout(s));
1138 if (r < 0)
1139 return r;
1140
1141 if (s->main_pid > 0 &&
1142 pid_is_unwaited(s->main_pid) &&
1143 (IN_SET(s->deserialized_state,
1144 SERVICE_START, SERVICE_START_POST,
1145 SERVICE_RUNNING, SERVICE_RELOAD,
1146 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1147 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1148 r = unit_watch_pid(UNIT(s), s->main_pid);
1149 if (r < 0)
1150 return r;
1151 }
1152
1153 if (s->control_pid > 0 &&
1154 pid_is_unwaited(s->control_pid) &&
1155 IN_SET(s->deserialized_state,
1156 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1157 SERVICE_RELOAD,
1158 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1159 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1160 r = unit_watch_pid(UNIT(s), s->control_pid);
1161 if (r < 0)
1162 return r;
1163 }
1164
1165 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
1166 (void) unit_enqueue_rewatch_pids(u);
1167 (void) unit_setup_dynamic_creds(u);
1168 (void) unit_setup_exec_runtime(u);
1169 }
1170
1171 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1172 service_start_watchdog(s);
1173
1174 if (UNIT_ISSET(s->accept_socket)) {
1175 Socket* socket = SOCKET(UNIT_DEREF(s->accept_socket));
1176
1177 if (socket->max_connections_per_source > 0) {
1178 SocketPeer *peer;
1179
1180 /* Make a best-effort attempt at bumping the connection count */
1181 if (socket_acquire_peer(socket, s->socket_fd, &peer) > 0) {
1182 socket_peer_unref(s->peer);
1183 s->peer = peer;
1184 }
1185 }
1186 }
1187
1188 service_set_state(s, s->deserialized_state);
1189 return 0;
1190 }
1191
1192 static int service_collect_fds(
1193 Service *s,
1194 int **fds,
1195 char ***fd_names,
1196 size_t *n_socket_fds,
1197 size_t *n_storage_fds) {
1198
1199 _cleanup_strv_free_ char **rfd_names = NULL;
1200 _cleanup_free_ int *rfds = NULL;
1201 size_t rn_socket_fds = 0, rn_storage_fds = 0;
1202 int r;
1203
1204 assert(s);
1205 assert(fds);
1206 assert(fd_names);
1207 assert(n_socket_fds);
1208 assert(n_storage_fds);
1209
1210 if (s->socket_fd >= 0) {
1211
1212 /* Pass the per-connection socket */
1213
1214 rfds = new(int, 1);
1215 if (!rfds)
1216 return -ENOMEM;
1217 rfds[0] = s->socket_fd;
1218
1219 rfd_names = strv_new("connection", NULL);
1220 if (!rfd_names)
1221 return -ENOMEM;
1222
1223 rn_socket_fds = 1;
1224 } else {
1225 Iterator i;
1226 void *v;
1227 Unit *u;
1228
1229 /* Pass all our configured sockets for singleton services */
1230
1231 HASHMAP_FOREACH_KEY(v, u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1232 _cleanup_free_ int *cfds = NULL;
1233 Socket *sock;
1234 int cn_fds;
1235
1236 if (u->type != UNIT_SOCKET)
1237 continue;
1238
1239 sock = SOCKET(u);
1240
1241 cn_fds = socket_collect_fds(sock, &cfds);
1242 if (cn_fds < 0)
1243 return cn_fds;
1244
1245 if (cn_fds <= 0)
1246 continue;
1247
1248 if (!rfds) {
1249 rfds = TAKE_PTR(cfds);
1250 rn_socket_fds = cn_fds;
1251 } else {
1252 int *t;
1253
1254 t = reallocarray(rfds, rn_socket_fds + cn_fds, sizeof(int));
1255 if (!t)
1256 return -ENOMEM;
1257
1258 memcpy(t + rn_socket_fds, cfds, cn_fds * sizeof(int));
1259
1260 rfds = t;
1261 rn_socket_fds += cn_fds;
1262 }
1263
1264 r = strv_extend_n(&rfd_names, socket_fdname(sock), cn_fds);
1265 if (r < 0)
1266 return r;
1267 }
1268 }
1269
1270 if (s->n_fd_store > 0) {
1271 ServiceFDStore *fs;
1272 size_t n_fds;
1273 char **nl;
1274 int *t;
1275
1276 t = reallocarray(rfds, rn_socket_fds + s->n_fd_store, sizeof(int));
1277 if (!t)
1278 return -ENOMEM;
1279
1280 rfds = t;
1281
1282 nl = reallocarray(rfd_names, rn_socket_fds + s->n_fd_store + 1, sizeof(char *));
1283 if (!nl)
1284 return -ENOMEM;
1285
1286 rfd_names = nl;
1287 n_fds = rn_socket_fds;
1288
1289 LIST_FOREACH(fd_store, fs, s->fd_store) {
1290 rfds[n_fds] = fs->fd;
1291 rfd_names[n_fds] = strdup(strempty(fs->fdname));
1292 if (!rfd_names[n_fds])
1293 return -ENOMEM;
1294
1295 rn_storage_fds++;
1296 n_fds++;
1297 }
1298
1299 rfd_names[n_fds] = NULL;
1300 }
1301
1302 *fds = TAKE_PTR(rfds);
1303 *fd_names = TAKE_PTR(rfd_names);
1304 *n_socket_fds = rn_socket_fds;
1305 *n_storage_fds = rn_storage_fds;
1306
1307 return 0;
1308 }
1309
1310 static int service_allocate_exec_fd_event_source(
1311 Service *s,
1312 int fd,
1313 sd_event_source **ret_event_source) {
1314
1315 _cleanup_(sd_event_source_unrefp) sd_event_source *source = NULL;
1316 int r;
1317
1318 assert(s);
1319 assert(fd >= 0);
1320 assert(ret_event_source);
1321
1322 r = sd_event_add_io(UNIT(s)->manager->event, &source, fd, 0, service_dispatch_exec_io, s);
1323 if (r < 0)
1324 return log_unit_error_errno(UNIT(s), r, "Failed to allocate exec_fd event source: %m");
1325
1326 /* This is a bit lower priority than SIGCHLD, as that carries a lot more interesting failure information */
1327
1328 r = sd_event_source_set_priority(source, SD_EVENT_PRIORITY_NORMAL-3);
1329 if (r < 0)
1330 return log_unit_error_errno(UNIT(s), r, "Failed to adjust priority of exec_fd event source: %m");
1331
1332 (void) sd_event_source_set_description(source, "service event_fd");
1333
1334 r = sd_event_source_set_io_fd_own(source, true);
1335 if (r < 0)
1336 return log_unit_error_errno(UNIT(s), r, "Failed to pass ownership of fd to event source: %m");
1337
1338 *ret_event_source = TAKE_PTR(source);
1339 return 0;
1340 }
1341
1342 static int service_allocate_exec_fd(
1343 Service *s,
1344 sd_event_source **ret_event_source,
1345 int* ret_exec_fd) {
1346
1347 _cleanup_close_pair_ int p[2] = { -1, -1 };
1348 int r;
1349
1350 assert(s);
1351 assert(ret_event_source);
1352 assert(ret_exec_fd);
1353
1354 if (pipe2(p, O_CLOEXEC|O_NONBLOCK) < 0)
1355 return log_unit_error_errno(UNIT(s), errno, "Failed to allocate exec_fd pipe: %m");
1356
1357 r = service_allocate_exec_fd_event_source(s, p[0], ret_event_source);
1358 if (r < 0)
1359 return r;
1360
1361 p[0] = -1;
1362 *ret_exec_fd = TAKE_FD(p[1]);
1363
1364 return 0;
1365 }
1366
1367 static bool service_exec_needs_notify_socket(Service *s, ExecFlags flags) {
1368 assert(s);
1369
1370 /* Notifications are accepted depending on the process and
1371 * the access setting of the service:
1372 * process: \ access: NONE MAIN EXEC ALL
1373 * main no yes yes yes
1374 * control no no yes yes
1375 * other (forked) no no no yes */
1376
1377 if (flags & EXEC_IS_CONTROL)
1378 /* A control process */
1379 return IN_SET(s->notify_access, NOTIFY_EXEC, NOTIFY_ALL);
1380
1381 /* We only spawn main processes and control processes, so any
1382 * process that is not a control process is a main process */
1383 return s->notify_access != NOTIFY_NONE;
1384 }
1385
1386 static int service_spawn(
1387 Service *s,
1388 ExecCommand *c,
1389 usec_t timeout,
1390 ExecFlags flags,
1391 pid_t *_pid) {
1392
1393 ExecParameters exec_params = {
1394 .flags = flags,
1395 .stdin_fd = -1,
1396 .stdout_fd = -1,
1397 .stderr_fd = -1,
1398 .exec_fd = -1,
1399 };
1400 _cleanup_strv_free_ char **final_env = NULL, **our_env = NULL, **fd_names = NULL;
1401 _cleanup_(sd_event_source_unrefp) sd_event_source *exec_fd_source = NULL;
1402 size_t n_socket_fds = 0, n_storage_fds = 0, n_env = 0;
1403 _cleanup_close_ int exec_fd = -1;
1404 _cleanup_free_ int *fds = NULL;
1405 pid_t pid;
1406 int r;
1407
1408 assert(s);
1409 assert(c);
1410 assert(_pid);
1411
1412 r = unit_prepare_exec(UNIT(s));
1413 if (r < 0)
1414 return r;
1415
1416 if (flags & EXEC_IS_CONTROL) {
1417 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1418 if (s->permissions_start_only)
1419 exec_params.flags &= ~EXEC_APPLY_SANDBOXING;
1420 if (s->root_directory_start_only)
1421 exec_params.flags &= ~EXEC_APPLY_CHROOT;
1422 }
1423
1424 if ((flags & EXEC_PASS_FDS) ||
1425 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1426 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1427 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1428
1429 r = service_collect_fds(s, &fds, &fd_names, &n_socket_fds, &n_storage_fds);
1430 if (r < 0)
1431 return r;
1432
1433 log_unit_debug(UNIT(s), "Passing %zu fds to service", n_socket_fds + n_storage_fds);
1434 }
1435
1436 if (!FLAGS_SET(flags, EXEC_IS_CONTROL) && s->type == SERVICE_EXEC) {
1437 assert(!s->exec_fd_event_source);
1438
1439 r = service_allocate_exec_fd(s, &exec_fd_source, &exec_fd);
1440 if (r < 0)
1441 return r;
1442 }
1443
1444 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), timeout));
1445 if (r < 0)
1446 return r;
1447
1448 our_env = new0(char*, 9);
1449 if (!our_env)
1450 return -ENOMEM;
1451
1452 if (service_exec_needs_notify_socket(s, flags))
1453 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0)
1454 return -ENOMEM;
1455
1456 if (s->main_pid > 0)
1457 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0)
1458 return -ENOMEM;
1459
1460 if (MANAGER_IS_USER(UNIT(s)->manager))
1461 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid_cached()) < 0)
1462 return -ENOMEM;
1463
1464 if (s->socket_fd >= 0) {
1465 union sockaddr_union sa;
1466 socklen_t salen = sizeof(sa);
1467
1468 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1469 * useful. Note that we do this only when we are still connected at this point in time, which we might
1470 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1471 * in ENOTCONN), and just use whate we can use. */
1472
1473 if (getpeername(s->socket_fd, &sa.sa, &salen) >= 0 &&
1474 IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
1475
1476 _cleanup_free_ char *addr = NULL;
1477 char *t;
1478 unsigned port;
1479
1480 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1481 if (r < 0)
1482 return r;
1483
1484 t = strappend("REMOTE_ADDR=", addr);
1485 if (!t)
1486 return -ENOMEM;
1487 our_env[n_env++] = t;
1488
1489 r = sockaddr_port(&sa.sa, &port);
1490 if (r < 0)
1491 return r;
1492
1493 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
1494 return -ENOMEM;
1495 our_env[n_env++] = t;
1496 }
1497 }
1498
1499 if (flags & EXEC_SETENV_RESULT) {
1500 if (asprintf(our_env + n_env++, "SERVICE_RESULT=%s", service_result_to_string(s->result)) < 0)
1501 return -ENOMEM;
1502
1503 if (s->main_exec_status.pid > 0 &&
1504 dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1505 if (asprintf(our_env + n_env++, "EXIT_CODE=%s", sigchld_code_to_string(s->main_exec_status.code)) < 0)
1506 return -ENOMEM;
1507
1508 if (s->main_exec_status.code == CLD_EXITED)
1509 r = asprintf(our_env + n_env++, "EXIT_STATUS=%i", s->main_exec_status.status);
1510 else
1511 r = asprintf(our_env + n_env++, "EXIT_STATUS=%s", signal_to_string(s->main_exec_status.status));
1512 if (r < 0)
1513 return -ENOMEM;
1514 }
1515 }
1516
1517 unit_set_exec_params(UNIT(s), &exec_params);
1518
1519 final_env = strv_env_merge(2, exec_params.environment, our_env, NULL);
1520 if (!final_env)
1521 return -ENOMEM;
1522
1523 /* System services should get a new keyring by default. */
1524 SET_FLAG(exec_params.flags, EXEC_NEW_KEYRING, MANAGER_IS_SYSTEM(UNIT(s)->manager));
1525
1526 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1527 SET_FLAG(exec_params.flags, EXEC_NSS_BYPASS_BUS,
1528 MANAGER_IS_SYSTEM(UNIT(s)->manager) && unit_has_name(UNIT(s), SPECIAL_DBUS_SERVICE));
1529
1530 exec_params.environment = final_env;
1531 exec_params.fds = fds;
1532 exec_params.fd_names = fd_names;
1533 exec_params.n_socket_fds = n_socket_fds;
1534 exec_params.n_storage_fds = n_storage_fds;
1535 exec_params.watchdog_usec = s->watchdog_usec;
1536 exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
1537 if (s->type == SERVICE_IDLE)
1538 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1539 exec_params.stdin_fd = s->stdin_fd;
1540 exec_params.stdout_fd = s->stdout_fd;
1541 exec_params.stderr_fd = s->stderr_fd;
1542 exec_params.exec_fd = exec_fd;
1543
1544 r = exec_spawn(UNIT(s),
1545 c,
1546 &s->exec_context,
1547 &exec_params,
1548 s->exec_runtime,
1549 &s->dynamic_creds,
1550 &pid);
1551 if (r < 0)
1552 return r;
1553
1554 s->exec_fd_event_source = TAKE_PTR(exec_fd_source);
1555 s->exec_fd_hot = false;
1556
1557 r = unit_watch_pid(UNIT(s), pid);
1558 if (r < 0) /* FIXME: we need to do something here */
1559 return r;
1560
1561 *_pid = pid;
1562
1563 return 0;
1564 }
1565
1566 static int main_pid_good(Service *s) {
1567 assert(s);
1568
1569 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1570
1571 /* If we know the pid file, then let's just check if it is
1572 * still valid */
1573 if (s->main_pid_known) {
1574
1575 /* If it's an alien child let's check if it is still
1576 * alive ... */
1577 if (s->main_pid_alien && s->main_pid > 0)
1578 return pid_is_alive(s->main_pid);
1579
1580 /* .. otherwise assume we'll get a SIGCHLD for it,
1581 * which we really should wait for to collect exit
1582 * status and code */
1583 return s->main_pid > 0;
1584 }
1585
1586 /* We don't know the pid */
1587 return -EAGAIN;
1588 }
1589
1590 static int control_pid_good(Service *s) {
1591 assert(s);
1592
1593 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1594 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1595 * means: we can't figure it out. */
1596
1597 return s->control_pid > 0;
1598 }
1599
1600 static int cgroup_good(Service *s) {
1601 int r;
1602
1603 assert(s);
1604
1605 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1606 * figure it out */
1607
1608 if (!UNIT(s)->cgroup_path)
1609 return 0;
1610
1611 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path);
1612 if (r < 0)
1613 return r;
1614
1615 return r == 0;
1616 }
1617
1618 static bool service_shall_restart(Service *s) {
1619 assert(s);
1620
1621 /* Don't restart after manual stops */
1622 if (s->forbid_restart)
1623 return false;
1624
1625 /* Never restart if this is configured as special exception */
1626 if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status))
1627 return false;
1628
1629 /* Restart if the exit code/status are configured as restart triggers */
1630 if (exit_status_set_test(&s->restart_force_status, s->main_exec_status.code, s->main_exec_status.status))
1631 return true;
1632
1633 switch (s->restart) {
1634
1635 case SERVICE_RESTART_NO:
1636 return false;
1637
1638 case SERVICE_RESTART_ALWAYS:
1639 return true;
1640
1641 case SERVICE_RESTART_ON_SUCCESS:
1642 return s->result == SERVICE_SUCCESS;
1643
1644 case SERVICE_RESTART_ON_FAILURE:
1645 return s->result != SERVICE_SUCCESS;
1646
1647 case SERVICE_RESTART_ON_ABNORMAL:
1648 return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE);
1649
1650 case SERVICE_RESTART_ON_WATCHDOG:
1651 return s->result == SERVICE_FAILURE_WATCHDOG;
1652
1653 case SERVICE_RESTART_ON_ABORT:
1654 return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
1655
1656 default:
1657 assert_not_reached("unknown restart setting");
1658 }
1659 }
1660
1661 static bool service_will_restart(Unit *u) {
1662 Service *s = SERVICE(u);
1663
1664 assert(s);
1665
1666 if (s->will_auto_restart)
1667 return true;
1668 if (s->state == SERVICE_AUTO_RESTART)
1669 return true;
1670 if (!UNIT(s)->job)
1671 return false;
1672 if (UNIT(s)->job->type == JOB_START)
1673 return true;
1674
1675 return false;
1676 }
1677
1678 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1679 int r;
1680
1681 assert(s);
1682
1683 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1684 * undo what has already been enqueued. */
1685 if (unit_stop_pending(UNIT(s)))
1686 allow_restart = false;
1687
1688 if (s->result == SERVICE_SUCCESS)
1689 s->result = f;
1690
1691 if (s->result != SERVICE_SUCCESS)
1692 log_unit_warning(UNIT(s), "Failed with result '%s'.", service_result_to_string(s->result));
1693
1694 if (allow_restart && service_shall_restart(s))
1695 s->will_auto_restart = true;
1696
1697 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1698 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1699 s->n_keep_fd_store ++;
1700
1701 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1702
1703 if (s->will_auto_restart) {
1704 s->will_auto_restart = false;
1705
1706 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1707 if (r < 0) {
1708 s->n_keep_fd_store--;
1709 goto fail;
1710 }
1711
1712 service_set_state(s, SERVICE_AUTO_RESTART);
1713 } else
1714 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1715 * user can still introspect the counter. Do so on the next start. */
1716 s->flush_n_restarts = true;
1717
1718 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1719 * queue, so that the fd store is possibly gc'ed again */
1720 s->n_keep_fd_store--;
1721 unit_add_to_gc_queue(UNIT(s));
1722
1723 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1724 s->forbid_restart = false;
1725
1726 /* We want fresh tmpdirs in case service is started again immediately */
1727 s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
1728
1729 if (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_NO ||
1730 (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_RESTART && !service_will_restart(UNIT(s))))
1731 /* Also, remove the runtime directory */
1732 exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
1733
1734 /* Get rid of the IPC bits of the user */
1735 unit_unref_uid_gid(UNIT(s), true);
1736
1737 /* Release the user, and destroy it if we are the only remaining owner */
1738 dynamic_creds_destroy(&s->dynamic_creds);
1739
1740 /* Try to delete the pid file. At this point it will be
1741 * out-of-date, and some software might be confused by it, so
1742 * let's remove it. */
1743 if (s->pid_file)
1744 (void) unlink(s->pid_file);
1745
1746 return;
1747
1748 fail:
1749 log_unit_warning_errno(UNIT(s), r, "Failed to run install restart timer: %m");
1750 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1751 }
1752
1753 static void service_enter_stop_post(Service *s, ServiceResult f) {
1754 int r;
1755 assert(s);
1756
1757 if (s->result == SERVICE_SUCCESS)
1758 s->result = f;
1759
1760 service_unwatch_control_pid(s);
1761 (void) unit_enqueue_rewatch_pids(UNIT(s));
1762
1763 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1764 if (s->control_command) {
1765 s->control_command_id = SERVICE_EXEC_STOP_POST;
1766
1767 r = service_spawn(s,
1768 s->control_command,
1769 s->timeout_stop_usec,
1770 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1771 &s->control_pid);
1772 if (r < 0)
1773 goto fail;
1774
1775 service_set_state(s, SERVICE_STOP_POST);
1776 } else
1777 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1778
1779 return;
1780
1781 fail:
1782 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
1783 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1784 }
1785
1786 static int state_to_kill_operation(ServiceState state) {
1787 switch (state) {
1788
1789 case SERVICE_STOP_WATCHDOG:
1790 return KILL_WATCHDOG;
1791
1792 case SERVICE_STOP_SIGTERM:
1793 case SERVICE_FINAL_SIGTERM:
1794 return KILL_TERMINATE;
1795
1796 case SERVICE_STOP_SIGKILL:
1797 case SERVICE_FINAL_SIGKILL:
1798 return KILL_KILL;
1799
1800 default:
1801 return _KILL_OPERATION_INVALID;
1802 }
1803 }
1804
1805 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1806 int r;
1807
1808 assert(s);
1809
1810 if (s->result == SERVICE_SUCCESS)
1811 s->result = f;
1812
1813 /* Before sending any signal, make sure we track all members of this cgroup */
1814 (void) unit_watch_all_pids(UNIT(s));
1815
1816 /* Also, enqueue a job that we recheck all our PIDs a bit later, given that it's likely some processes have
1817 * died now */
1818 (void) unit_enqueue_rewatch_pids(UNIT(s));
1819
1820 r = unit_kill_context(
1821 UNIT(s),
1822 &s->kill_context,
1823 state_to_kill_operation(state),
1824 s->main_pid,
1825 s->control_pid,
1826 s->main_pid_alien);
1827 if (r < 0)
1828 goto fail;
1829
1830 if (r > 0) {
1831 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1832 if (r < 0)
1833 goto fail;
1834
1835 service_set_state(s, state);
1836 } else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
1837 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1838 else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1839 service_enter_stop_post(s, SERVICE_SUCCESS);
1840 else if (state == SERVICE_FINAL_SIGTERM && s->kill_context.send_sigkill)
1841 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1842 else
1843 service_enter_dead(s, SERVICE_SUCCESS, true);
1844
1845 return;
1846
1847 fail:
1848 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
1849
1850 if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1851 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1852 else
1853 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1854 }
1855
1856 static void service_enter_stop_by_notify(Service *s) {
1857 assert(s);
1858
1859 (void) unit_enqueue_rewatch_pids(UNIT(s));
1860
1861 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1862
1863 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1864 service_set_state(s, SERVICE_STOP_SIGTERM);
1865 }
1866
1867 static void service_enter_stop(Service *s, ServiceResult f) {
1868 int r;
1869
1870 assert(s);
1871
1872 if (s->result == SERVICE_SUCCESS)
1873 s->result = f;
1874
1875 service_unwatch_control_pid(s);
1876 (void) unit_enqueue_rewatch_pids(UNIT(s));
1877
1878 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1879 if (s->control_command) {
1880 s->control_command_id = SERVICE_EXEC_STOP;
1881
1882 r = service_spawn(s,
1883 s->control_command,
1884 s->timeout_stop_usec,
1885 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1886 &s->control_pid);
1887 if (r < 0)
1888 goto fail;
1889
1890 service_set_state(s, SERVICE_STOP);
1891 } else
1892 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1893
1894 return;
1895
1896 fail:
1897 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop' task: %m");
1898 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1899 }
1900
1901 static bool service_good(Service *s) {
1902 int main_pid_ok;
1903 assert(s);
1904
1905 if (s->type == SERVICE_DBUS && !s->bus_name_good)
1906 return false;
1907
1908 main_pid_ok = main_pid_good(s);
1909 if (main_pid_ok > 0) /* It's alive */
1910 return true;
1911 if (main_pid_ok == 0) /* It's dead */
1912 return false;
1913
1914 /* OK, we don't know anything about the main PID, maybe
1915 * because there is none. Let's check the control group
1916 * instead. */
1917
1918 return cgroup_good(s) != 0;
1919 }
1920
1921 static void service_enter_running(Service *s, ServiceResult f) {
1922 assert(s);
1923
1924 if (s->result == SERVICE_SUCCESS)
1925 s->result = f;
1926
1927 service_unwatch_control_pid(s);
1928
1929 if (s->result != SERVICE_SUCCESS)
1930 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
1931 else if (service_good(s)) {
1932
1933 /* If there are any queued up sd_notify() notifications, process them now */
1934 if (s->notify_state == NOTIFY_RELOADING)
1935 service_enter_reload_by_notify(s);
1936 else if (s->notify_state == NOTIFY_STOPPING)
1937 service_enter_stop_by_notify(s);
1938 else {
1939 service_set_state(s, SERVICE_RUNNING);
1940 service_arm_timer(s, usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec));
1941 }
1942
1943 } else if (s->remain_after_exit)
1944 service_set_state(s, SERVICE_EXITED);
1945 else
1946 service_enter_stop(s, SERVICE_SUCCESS);
1947 }
1948
1949 static void service_enter_start_post(Service *s) {
1950 int r;
1951 assert(s);
1952
1953 service_unwatch_control_pid(s);
1954 service_reset_watchdog(s);
1955
1956 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1957 if (s->control_command) {
1958 s->control_command_id = SERVICE_EXEC_START_POST;
1959
1960 r = service_spawn(s,
1961 s->control_command,
1962 s->timeout_start_usec,
1963 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
1964 &s->control_pid);
1965 if (r < 0)
1966 goto fail;
1967
1968 service_set_state(s, SERVICE_START_POST);
1969 } else
1970 service_enter_running(s, SERVICE_SUCCESS);
1971
1972 return;
1973
1974 fail:
1975 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
1976 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1977 }
1978
1979 static void service_kill_control_process(Service *s) {
1980 int r;
1981
1982 assert(s);
1983
1984 if (s->control_pid <= 0)
1985 return;
1986
1987 r = kill_and_sigcont(s->control_pid, SIGKILL);
1988 if (r < 0) {
1989 _cleanup_free_ char *comm = NULL;
1990
1991 (void) get_process_comm(s->control_pid, &comm);
1992
1993 log_unit_debug_errno(UNIT(s), r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m",
1994 s->control_pid, strna(comm));
1995 }
1996 }
1997
1998 static void service_enter_start(Service *s) {
1999 ExecCommand *c;
2000 usec_t timeout;
2001 pid_t pid;
2002 int r;
2003
2004 assert(s);
2005
2006 service_unwatch_control_pid(s);
2007 service_unwatch_main_pid(s);
2008
2009 unit_warn_leftover_processes(UNIT(s));
2010
2011 if (s->type == SERVICE_FORKING) {
2012 s->control_command_id = SERVICE_EXEC_START;
2013 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2014
2015 s->main_command = NULL;
2016 } else {
2017 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2018 s->control_command = NULL;
2019
2020 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2021 }
2022
2023 if (!c) {
2024 if (s->type != SERVICE_ONESHOT) {
2025 /* There's no command line configured for the main command? Hmm, that is strange. This can only
2026 * happen if the configuration changes at runtime. In this case, let's enter a failure
2027 * state. */
2028 log_unit_error(UNIT(s), "There's no 'start' task anymore we could start.");
2029 r = -ENXIO;
2030 goto fail;
2031 }
2032
2033 /* We force a fake state transition here. Otherwise, the unit would go directly from
2034 * SERVICE_DEAD to SERVICE_DEAD without SERVICE_ACTIVATING or SERVICE_ACTIVE
2035 * inbetween. This way we can later trigger actions that depend on the state
2036 * transition, including SuccessAction=. */
2037 service_set_state(s, SERVICE_START);
2038
2039 service_enter_start_post(s);
2040 return;
2041 }
2042
2043 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
2044 /* For simple + idle this is the main process. We don't apply any timeout here, but
2045 * service_enter_running() will later apply the .runtime_max_usec timeout. */
2046 timeout = USEC_INFINITY;
2047 else
2048 timeout = s->timeout_start_usec;
2049
2050 r = service_spawn(s,
2051 c,
2052 timeout,
2053 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2054 &pid);
2055 if (r < 0)
2056 goto fail;
2057
2058 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE)) {
2059 /* For simple services we immediately start
2060 * the START_POST binaries. */
2061
2062 service_set_main_pid(s, pid);
2063 service_enter_start_post(s);
2064
2065 } else if (s->type == SERVICE_FORKING) {
2066
2067 /* For forking services we wait until the start
2068 * process exited. */
2069
2070 s->control_pid = pid;
2071 service_set_state(s, SERVICE_START);
2072
2073 } else if (IN_SET(s->type, SERVICE_ONESHOT, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_EXEC)) {
2074
2075 /* For oneshot services we wait until the start process exited, too, but it is our main process. */
2076
2077 /* For D-Bus services we know the main pid right away, but wait for the bus name to appear on the
2078 * bus. 'notify' and 'exec' services are similar. */
2079
2080 service_set_main_pid(s, pid);
2081 service_set_state(s, SERVICE_START);
2082 } else
2083 assert_not_reached("Unknown service type");
2084
2085 return;
2086
2087 fail:
2088 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start' task: %m");
2089 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2090 }
2091
2092 static void service_enter_start_pre(Service *s) {
2093 int r;
2094
2095 assert(s);
2096
2097 service_unwatch_control_pid(s);
2098
2099 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2100 if (s->control_command) {
2101
2102 unit_warn_leftover_processes(UNIT(s));
2103
2104 s->control_command_id = SERVICE_EXEC_START_PRE;
2105
2106 r = service_spawn(s,
2107 s->control_command,
2108 s->timeout_start_usec,
2109 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_APPLY_TTY_STDIN,
2110 &s->control_pid);
2111 if (r < 0)
2112 goto fail;
2113
2114 service_set_state(s, SERVICE_START_PRE);
2115 } else
2116 service_enter_start(s);
2117
2118 return;
2119
2120 fail:
2121 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2122 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2123 }
2124
2125 static void service_enter_restart(Service *s) {
2126 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2127 int r;
2128
2129 assert(s);
2130
2131 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2132 /* Don't restart things if we are going down anyway */
2133 log_unit_info(UNIT(s), "Stop job pending for unit, delaying automatic restart.");
2134
2135 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
2136 if (r < 0)
2137 goto fail;
2138
2139 return;
2140 }
2141
2142 /* Any units that are bound to this service must also be
2143 * restarted. We use JOB_RESTART (instead of the more obvious
2144 * JOB_START) here so that those dependency jobs will be added
2145 * as well. */
2146 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, &error, NULL);
2147 if (r < 0)
2148 goto fail;
2149
2150 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2151 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2152 * explicitly however via the usual "systemctl reset-failure" logic. */
2153 s->n_restarts ++;
2154 s->flush_n_restarts = false;
2155
2156 log_struct(LOG_INFO,
2157 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR,
2158 LOG_UNIT_ID(UNIT(s)),
2159 LOG_UNIT_INVOCATION_ID(UNIT(s)),
2160 LOG_UNIT_MESSAGE(UNIT(s), "Scheduled restart job, restart counter is at %u.", s->n_restarts),
2161 "N_RESTARTS=%u", s->n_restarts);
2162
2163 /* Notify clients about changed restart counter */
2164 unit_add_to_dbus_queue(UNIT(s));
2165
2166 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2167 * it will be canceled as part of the service_stop() call that
2168 * is executed as part of JOB_RESTART. */
2169
2170 return;
2171
2172 fail:
2173 log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, -r));
2174 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2175 }
2176
2177 static void service_enter_reload_by_notify(Service *s) {
2178 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2179 int r;
2180
2181 assert(s);
2182
2183 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_start_usec));
2184 service_set_state(s, SERVICE_RELOAD);
2185
2186 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2187 r = manager_propagate_reload(UNIT(s)->manager, UNIT(s), JOB_FAIL, &error);
2188 if (r < 0)
2189 log_unit_warning(UNIT(s), "Failed to schedule propagation of reload: %s", bus_error_message(&error, -r));
2190 }
2191
2192 static void service_enter_reload(Service *s) {
2193 int r;
2194
2195 assert(s);
2196
2197 service_unwatch_control_pid(s);
2198 s->reload_result = SERVICE_SUCCESS;
2199
2200 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2201 if (s->control_command) {
2202 s->control_command_id = SERVICE_EXEC_RELOAD;
2203
2204 r = service_spawn(s,
2205 s->control_command,
2206 s->timeout_start_usec,
2207 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
2208 &s->control_pid);
2209 if (r < 0)
2210 goto fail;
2211
2212 service_set_state(s, SERVICE_RELOAD);
2213 } else
2214 service_enter_running(s, SERVICE_SUCCESS);
2215
2216 return;
2217
2218 fail:
2219 log_unit_warning_errno(UNIT(s), r, "Failed to run 'reload' task: %m");
2220 s->reload_result = SERVICE_FAILURE_RESOURCES;
2221 service_enter_running(s, SERVICE_SUCCESS);
2222 }
2223
2224 static void service_run_next_control(Service *s) {
2225 usec_t timeout;
2226 int r;
2227
2228 assert(s);
2229 assert(s->control_command);
2230 assert(s->control_command->command_next);
2231
2232 assert(s->control_command_id != SERVICE_EXEC_START);
2233
2234 s->control_command = s->control_command->command_next;
2235 service_unwatch_control_pid(s);
2236
2237 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
2238 timeout = s->timeout_start_usec;
2239 else
2240 timeout = s->timeout_stop_usec;
2241
2242 r = service_spawn(s,
2243 s->control_command,
2244 timeout,
2245 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|
2246 (IN_SET(s->control_command_id, SERVICE_EXEC_START_PRE, SERVICE_EXEC_STOP_POST) ? EXEC_APPLY_TTY_STDIN : 0)|
2247 (IN_SET(s->control_command_id, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST) ? EXEC_SETENV_RESULT : 0),
2248 &s->control_pid);
2249 if (r < 0)
2250 goto fail;
2251
2252 return;
2253
2254 fail:
2255 log_unit_warning_errno(UNIT(s), r, "Failed to run next control task: %m");
2256
2257 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START_POST, SERVICE_STOP))
2258 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2259 else if (s->state == SERVICE_STOP_POST)
2260 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2261 else if (s->state == SERVICE_RELOAD) {
2262 s->reload_result = SERVICE_FAILURE_RESOURCES;
2263 service_enter_running(s, SERVICE_SUCCESS);
2264 } else
2265 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2266 }
2267
2268 static void service_run_next_main(Service *s) {
2269 pid_t pid;
2270 int r;
2271
2272 assert(s);
2273 assert(s->main_command);
2274 assert(s->main_command->command_next);
2275 assert(s->type == SERVICE_ONESHOT);
2276
2277 s->main_command = s->main_command->command_next;
2278 service_unwatch_main_pid(s);
2279
2280 r = service_spawn(s,
2281 s->main_command,
2282 s->timeout_start_usec,
2283 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2284 &pid);
2285 if (r < 0)
2286 goto fail;
2287
2288 service_set_main_pid(s, pid);
2289
2290 return;
2291
2292 fail:
2293 log_unit_warning_errno(UNIT(s), r, "Failed to run next main task: %m");
2294 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2295 }
2296
2297 static int service_start(Unit *u) {
2298 Service *s = SERVICE(u);
2299 int r;
2300
2301 assert(s);
2302
2303 /* We cannot fulfill this request right now, try again later
2304 * please! */
2305 if (IN_SET(s->state,
2306 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2307 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2308 return -EAGAIN;
2309
2310 /* Already on it! */
2311 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST))
2312 return 0;
2313
2314 /* A service that will be restarted must be stopped first to
2315 * trigger BindsTo and/or OnFailure dependencies. If a user
2316 * does not want to wait for the holdoff time to elapse, the
2317 * service should be manually restarted, not started. We
2318 * simply return EAGAIN here, so that any start jobs stay
2319 * queued, and assume that the auto restart timer will
2320 * eventually trigger the restart. */
2321 if (s->state == SERVICE_AUTO_RESTART)
2322 return -EAGAIN;
2323
2324 assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED));
2325
2326 /* Make sure we don't enter a busy loop of some kind. */
2327 r = unit_start_limit_test(u);
2328 if (r < 0) {
2329 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT_HIT, false);
2330 return r;
2331 }
2332
2333 r = unit_acquire_invocation_id(u);
2334 if (r < 0)
2335 return r;
2336
2337 s->result = SERVICE_SUCCESS;
2338 s->reload_result = SERVICE_SUCCESS;
2339 s->main_pid_known = false;
2340 s->main_pid_alien = false;
2341 s->forbid_restart = false;
2342
2343 s->status_text = mfree(s->status_text);
2344 s->status_errno = 0;
2345
2346 s->notify_state = NOTIFY_UNKNOWN;
2347
2348 s->watchdog_override_enable = false;
2349 s->watchdog_override_usec = 0;
2350
2351 exec_command_reset_status_list_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
2352 exec_status_reset(&s->main_exec_status);
2353
2354 /* This is not an automatic restart? Flush the restart counter then */
2355 if (s->flush_n_restarts) {
2356 s->n_restarts = 0;
2357 s->flush_n_restarts = false;
2358 }
2359
2360 u->reset_accounting = true;
2361
2362 service_enter_start_pre(s);
2363 return 1;
2364 }
2365
2366 static int service_stop(Unit *u) {
2367 Service *s = SERVICE(u);
2368
2369 assert(s);
2370
2371 /* Don't create restart jobs from manual stops. */
2372 s->forbid_restart = true;
2373
2374 /* Already on it */
2375 if (IN_SET(s->state,
2376 SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2377 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2378 return 0;
2379
2380 /* A restart will be scheduled or is in progress. */
2381 if (s->state == SERVICE_AUTO_RESTART) {
2382 service_set_state(s, SERVICE_DEAD);
2383 return 0;
2384 }
2385
2386 /* If there's already something running we go directly into
2387 * kill mode. */
2388 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD)) {
2389 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2390 return 0;
2391 }
2392
2393 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2394
2395 service_enter_stop(s, SERVICE_SUCCESS);
2396 return 1;
2397 }
2398
2399 static int service_reload(Unit *u) {
2400 Service *s = SERVICE(u);
2401
2402 assert(s);
2403
2404 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2405
2406 service_enter_reload(s);
2407 return 1;
2408 }
2409
2410 _pure_ static bool service_can_reload(Unit *u) {
2411 Service *s = SERVICE(u);
2412
2413 assert(s);
2414
2415 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2416 }
2417
2418 static unsigned service_exec_command_index(Unit *u, ServiceExecCommand id, ExecCommand *current) {
2419 Service *s = SERVICE(u);
2420 unsigned idx = 0;
2421 ExecCommand *first, *c;
2422
2423 assert(s);
2424
2425 first = s->exec_command[id];
2426
2427 /* Figure out where we are in the list by walking back to the beginning */
2428 for (c = current; c != first; c = c->command_prev)
2429 idx++;
2430
2431 return idx;
2432 }
2433
2434 static int service_serialize_exec_command(Unit *u, FILE *f, ExecCommand *command) {
2435 _cleanup_free_ char *args = NULL, *p = NULL;
2436 size_t allocated = 0, length = 0;
2437 Service *s = SERVICE(u);
2438 const char *type, *key;
2439 ServiceExecCommand id;
2440 unsigned idx;
2441 char **arg;
2442
2443 assert(s);
2444 assert(f);
2445
2446 if (!command)
2447 return 0;
2448
2449 if (command == s->control_command) {
2450 type = "control";
2451 id = s->control_command_id;
2452 } else {
2453 type = "main";
2454 id = SERVICE_EXEC_START;
2455 }
2456
2457 idx = service_exec_command_index(u, id, command);
2458
2459 STRV_FOREACH(arg, command->argv) {
2460 _cleanup_free_ char *e = NULL;
2461 size_t n;
2462
2463 e = cescape(*arg);
2464 if (!e)
2465 return log_oom();
2466
2467 n = strlen(e);
2468 if (!GREEDY_REALLOC(args, allocated, length + 1 + n + 1))
2469 return log_oom();
2470
2471 if (length > 0)
2472 args[length++] = ' ';
2473
2474 memcpy(args + length, e, n);
2475 length += n;
2476 }
2477
2478 if (!GREEDY_REALLOC(args, allocated, length + 1))
2479 return log_oom();
2480
2481 args[length++] = 0;
2482
2483 p = cescape(command->path);
2484 if (!p)
2485 return -ENOMEM;
2486
2487 key = strjoina(type, "-command");
2488 return serialize_item_format(f, key, "%s %u %s %s", service_exec_command_to_string(id), idx, p, args);
2489 }
2490
2491 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2492 Service *s = SERVICE(u);
2493 ServiceFDStore *fs;
2494 int r;
2495
2496 assert(u);
2497 assert(f);
2498 assert(fds);
2499
2500 (void) serialize_item(f, "state", service_state_to_string(s->state));
2501 (void) serialize_item(f, "result", service_result_to_string(s->result));
2502 (void) serialize_item(f, "reload-result", service_result_to_string(s->reload_result));
2503
2504 if (s->control_pid > 0)
2505 (void) serialize_item_format(f, "control-pid", PID_FMT, s->control_pid);
2506
2507 if (s->main_pid_known && s->main_pid > 0)
2508 (void) serialize_item_format(f, "main-pid", PID_FMT, s->main_pid);
2509
2510 (void) serialize_bool(f, "main-pid-known", s->main_pid_known);
2511 (void) serialize_bool(f, "bus-name-good", s->bus_name_good);
2512 (void) serialize_bool(f, "bus-name-owner", s->bus_name_owner);
2513
2514 (void) serialize_item_format(f, "n-restarts", "%u", s->n_restarts);
2515 (void) serialize_bool(f, "flush-n-restarts", s->flush_n_restarts);
2516
2517 r = serialize_item_escaped(f, "status-text", s->status_text);
2518 if (r < 0)
2519 return r;
2520
2521 service_serialize_exec_command(u, f, s->control_command);
2522 service_serialize_exec_command(u, f, s->main_command);
2523
2524 r = serialize_fd(f, fds, "stdin-fd", s->stdin_fd);
2525 if (r < 0)
2526 return r;
2527 r = serialize_fd(f, fds, "stdout-fd", s->stdout_fd);
2528 if (r < 0)
2529 return r;
2530 r = serialize_fd(f, fds, "stderr-fd", s->stderr_fd);
2531 if (r < 0)
2532 return r;
2533
2534 if (s->exec_fd_event_source) {
2535 r = serialize_fd(f, fds, "exec-fd", sd_event_source_get_io_fd(s->exec_fd_event_source));
2536 if (r < 0)
2537 return r;
2538
2539 (void) serialize_bool(f, "exec-fd-hot", s->exec_fd_hot);
2540 }
2541
2542 if (UNIT_ISSET(s->accept_socket)) {
2543 r = serialize_item(f, "accept-socket", UNIT_DEREF(s->accept_socket)->id);
2544 if (r < 0)
2545 return r;
2546 }
2547
2548 r = serialize_fd(f, fds, "socket-fd", s->socket_fd);
2549 if (r < 0)
2550 return r;
2551
2552 LIST_FOREACH(fd_store, fs, s->fd_store) {
2553 _cleanup_free_ char *c = NULL;
2554 int copy;
2555
2556 copy = fdset_put_dup(fds, fs->fd);
2557 if (copy < 0)
2558 return log_error_errno(copy, "Failed to copy file descriptor for serialization: %m");
2559
2560 c = cescape(fs->fdname);
2561 if (!c)
2562 return log_oom();
2563
2564 (void) serialize_item_format(f, "fd-store-fd", "%i %s", copy, c);
2565 }
2566
2567 if (s->main_exec_status.pid > 0) {
2568 (void) serialize_item_format(f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
2569 (void) serialize_dual_timestamp(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2570 (void) serialize_dual_timestamp(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2571
2572 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2573 (void) serialize_item_format(f, "main-exec-status-code", "%i", s->main_exec_status.code);
2574 (void) serialize_item_format(f, "main-exec-status-status", "%i", s->main_exec_status.status);
2575 }
2576 }
2577
2578 (void) serialize_dual_timestamp(f, "watchdog-timestamp", &s->watchdog_timestamp);
2579 (void) serialize_bool(f, "forbid-restart", s->forbid_restart);
2580
2581 if (s->watchdog_override_enable)
2582 (void) serialize_item_format(f, "watchdog-override-usec", USEC_FMT, s->watchdog_override_usec);
2583
2584 return 0;
2585 }
2586
2587 static int service_deserialize_exec_command(Unit *u, const char *key, const char *value) {
2588 Service *s = SERVICE(u);
2589 int r;
2590 unsigned idx = 0, i;
2591 bool control, found = false;
2592 ServiceExecCommand id = _SERVICE_EXEC_COMMAND_INVALID;
2593 ExecCommand *command = NULL;
2594 _cleanup_free_ char *path = NULL;
2595 _cleanup_strv_free_ char **argv = NULL;
2596
2597 enum ExecCommandState {
2598 STATE_EXEC_COMMAND_TYPE,
2599 STATE_EXEC_COMMAND_INDEX,
2600 STATE_EXEC_COMMAND_PATH,
2601 STATE_EXEC_COMMAND_ARGS,
2602 _STATE_EXEC_COMMAND_MAX,
2603 _STATE_EXEC_COMMAND_INVALID = -1,
2604 } state;
2605
2606 assert(s);
2607 assert(key);
2608 assert(value);
2609
2610 control = streq(key, "control-command");
2611
2612 state = STATE_EXEC_COMMAND_TYPE;
2613
2614 for (;;) {
2615 _cleanup_free_ char *arg = NULL;
2616
2617 r = extract_first_word(&value, &arg, NULL, EXTRACT_CUNESCAPE);
2618 if (r < 0)
2619 return r;
2620 if (r == 0)
2621 break;
2622
2623 switch (state) {
2624 case STATE_EXEC_COMMAND_TYPE:
2625 id = service_exec_command_from_string(arg);
2626 if (id < 0)
2627 return -EINVAL;
2628
2629 state = STATE_EXEC_COMMAND_INDEX;
2630 break;
2631 case STATE_EXEC_COMMAND_INDEX:
2632 r = safe_atou(arg, &idx);
2633 if (r < 0)
2634 return -EINVAL;
2635
2636 state = STATE_EXEC_COMMAND_PATH;
2637 break;
2638 case STATE_EXEC_COMMAND_PATH:
2639 path = TAKE_PTR(arg);
2640 state = STATE_EXEC_COMMAND_ARGS;
2641
2642 if (!path_is_absolute(path))
2643 return -EINVAL;
2644 break;
2645 case STATE_EXEC_COMMAND_ARGS:
2646 r = strv_extend(&argv, arg);
2647 if (r < 0)
2648 return -ENOMEM;
2649 break;
2650 default:
2651 assert_not_reached("Unknown error at deserialization of exec command");
2652 break;
2653 }
2654 }
2655
2656 if (state != STATE_EXEC_COMMAND_ARGS)
2657 return -EINVAL;
2658
2659 /* Let's check whether exec command on given offset matches data that we just deserialized */
2660 for (command = s->exec_command[id], i = 0; command; command = command->command_next, i++) {
2661 if (i != idx)
2662 continue;
2663
2664 found = strv_equal(argv, command->argv) && streq(command->path, path);
2665 break;
2666 }
2667
2668 if (!found) {
2669 /* Command at the index we serialized is different, let's look for command that exactly
2670 * matches but is on different index. If there is no such command we will not resume execution. */
2671 for (command = s->exec_command[id]; command; command = command->command_next)
2672 if (strv_equal(command->argv, argv) && streq(command->path, path))
2673 break;
2674 }
2675
2676 if (command && control)
2677 s->control_command = command;
2678 else if (command)
2679 s->main_command = command;
2680 else
2681 log_unit_warning(u, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2682
2683 return 0;
2684 }
2685
2686 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2687 Service *s = SERVICE(u);
2688 int r;
2689
2690 assert(u);
2691 assert(key);
2692 assert(value);
2693 assert(fds);
2694
2695 if (streq(key, "state")) {
2696 ServiceState state;
2697
2698 state = service_state_from_string(value);
2699 if (state < 0)
2700 log_unit_debug(u, "Failed to parse state value: %s", value);
2701 else
2702 s->deserialized_state = state;
2703 } else if (streq(key, "result")) {
2704 ServiceResult f;
2705
2706 f = service_result_from_string(value);
2707 if (f < 0)
2708 log_unit_debug(u, "Failed to parse result value: %s", value);
2709 else if (f != SERVICE_SUCCESS)
2710 s->result = f;
2711
2712 } else if (streq(key, "reload-result")) {
2713 ServiceResult f;
2714
2715 f = service_result_from_string(value);
2716 if (f < 0)
2717 log_unit_debug(u, "Failed to parse reload result value: %s", value);
2718 else if (f != SERVICE_SUCCESS)
2719 s->reload_result = f;
2720
2721 } else if (streq(key, "control-pid")) {
2722 pid_t pid;
2723
2724 if (parse_pid(value, &pid) < 0)
2725 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2726 else
2727 s->control_pid = pid;
2728 } else if (streq(key, "main-pid")) {
2729 pid_t pid;
2730
2731 if (parse_pid(value, &pid) < 0)
2732 log_unit_debug(u, "Failed to parse main-pid value: %s", value);
2733 else
2734 (void) service_set_main_pid(s, pid);
2735 } else if (streq(key, "main-pid-known")) {
2736 int b;
2737
2738 b = parse_boolean(value);
2739 if (b < 0)
2740 log_unit_debug(u, "Failed to parse main-pid-known value: %s", value);
2741 else
2742 s->main_pid_known = b;
2743 } else if (streq(key, "bus-name-good")) {
2744 int b;
2745
2746 b = parse_boolean(value);
2747 if (b < 0)
2748 log_unit_debug(u, "Failed to parse bus-name-good value: %s", value);
2749 else
2750 s->bus_name_good = b;
2751 } else if (streq(key, "bus-name-owner")) {
2752 r = free_and_strdup(&s->bus_name_owner, value);
2753 if (r < 0)
2754 log_unit_error_errno(u, r, "Unable to deserialize current bus owner %s: %m", value);
2755 } else if (streq(key, "status-text")) {
2756 char *t;
2757
2758 r = cunescape(value, 0, &t);
2759 if (r < 0)
2760 log_unit_debug_errno(u, r, "Failed to unescape status text '%s': %m", value);
2761 else
2762 free_and_replace(s->status_text, t);
2763
2764 } else if (streq(key, "accept-socket")) {
2765 Unit *socket;
2766
2767 r = manager_load_unit(u->manager, value, NULL, NULL, &socket);
2768 if (r < 0)
2769 log_unit_debug_errno(u, r, "Failed to load accept-socket unit '%s': %m", value);
2770 else {
2771 unit_ref_set(&s->accept_socket, u, socket);
2772 SOCKET(socket)->n_connections++;
2773 }
2774
2775 } else if (streq(key, "socket-fd")) {
2776 int fd;
2777
2778 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2779 log_unit_debug(u, "Failed to parse socket-fd value: %s", value);
2780 else {
2781 asynchronous_close(s->socket_fd);
2782 s->socket_fd = fdset_remove(fds, fd);
2783 }
2784 } else if (streq(key, "fd-store-fd")) {
2785 const char *fdv;
2786 size_t pf;
2787 int fd;
2788
2789 pf = strcspn(value, WHITESPACE);
2790 fdv = strndupa(value, pf);
2791
2792 if (safe_atoi(fdv, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2793 log_unit_debug(u, "Failed to parse fd-store-fd value: %s", value);
2794 else {
2795 _cleanup_free_ char *t = NULL;
2796 const char *fdn;
2797
2798 fdn = value + pf;
2799 fdn += strspn(fdn, WHITESPACE);
2800 (void) cunescape(fdn, 0, &t);
2801
2802 r = service_add_fd_store(s, fd, t);
2803 if (r < 0)
2804 log_unit_error_errno(u, r, "Failed to add fd to store: %m");
2805 else
2806 fdset_remove(fds, fd);
2807 }
2808
2809 } else if (streq(key, "main-exec-status-pid")) {
2810 pid_t pid;
2811
2812 if (parse_pid(value, &pid) < 0)
2813 log_unit_debug(u, "Failed to parse main-exec-status-pid value: %s", value);
2814 else
2815 s->main_exec_status.pid = pid;
2816 } else if (streq(key, "main-exec-status-code")) {
2817 int i;
2818
2819 if (safe_atoi(value, &i) < 0)
2820 log_unit_debug(u, "Failed to parse main-exec-status-code value: %s", value);
2821 else
2822 s->main_exec_status.code = i;
2823 } else if (streq(key, "main-exec-status-status")) {
2824 int i;
2825
2826 if (safe_atoi(value, &i) < 0)
2827 log_unit_debug(u, "Failed to parse main-exec-status-status value: %s", value);
2828 else
2829 s->main_exec_status.status = i;
2830 } else if (streq(key, "main-exec-status-start"))
2831 deserialize_dual_timestamp(value, &s->main_exec_status.start_timestamp);
2832 else if (streq(key, "main-exec-status-exit"))
2833 deserialize_dual_timestamp(value, &s->main_exec_status.exit_timestamp);
2834 else if (streq(key, "watchdog-timestamp"))
2835 deserialize_dual_timestamp(value, &s->watchdog_timestamp);
2836 else if (streq(key, "forbid-restart")) {
2837 int b;
2838
2839 b = parse_boolean(value);
2840 if (b < 0)
2841 log_unit_debug(u, "Failed to parse forbid-restart value: %s", value);
2842 else
2843 s->forbid_restart = b;
2844 } else if (streq(key, "stdin-fd")) {
2845 int fd;
2846
2847 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2848 log_unit_debug(u, "Failed to parse stdin-fd value: %s", value);
2849 else {
2850 asynchronous_close(s->stdin_fd);
2851 s->stdin_fd = fdset_remove(fds, fd);
2852 s->exec_context.stdio_as_fds = true;
2853 }
2854 } else if (streq(key, "stdout-fd")) {
2855 int fd;
2856
2857 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2858 log_unit_debug(u, "Failed to parse stdout-fd value: %s", value);
2859 else {
2860 asynchronous_close(s->stdout_fd);
2861 s->stdout_fd = fdset_remove(fds, fd);
2862 s->exec_context.stdio_as_fds = true;
2863 }
2864 } else if (streq(key, "stderr-fd")) {
2865 int fd;
2866
2867 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2868 log_unit_debug(u, "Failed to parse stderr-fd value: %s", value);
2869 else {
2870 asynchronous_close(s->stderr_fd);
2871 s->stderr_fd = fdset_remove(fds, fd);
2872 s->exec_context.stdio_as_fds = true;
2873 }
2874 } else if (streq(key, "exec-fd")) {
2875 int fd;
2876
2877 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2878 log_unit_debug(u, "Failed to parse exec-fd value: %s", value);
2879 else {
2880 s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
2881
2882 fd = fdset_remove(fds, fd);
2883 if (service_allocate_exec_fd_event_source(s, fd, &s->exec_fd_event_source) < 0)
2884 safe_close(fd);
2885 }
2886 } else if (streq(key, "watchdog-override-usec")) {
2887 if (deserialize_usec(value, &s->watchdog_override_usec) < 0)
2888 log_unit_debug(u, "Failed to parse watchdog_override_usec value: %s", value);
2889 else
2890 s->watchdog_override_enable = true;
2891
2892 } else if (STR_IN_SET(key, "main-command", "control-command")) {
2893 r = service_deserialize_exec_command(u, key, value);
2894 if (r < 0)
2895 log_unit_debug_errno(u, r, "Failed to parse serialized command \"%s\": %m", value);
2896
2897 } else if (streq(key, "n-restarts")) {
2898 r = safe_atou(value, &s->n_restarts);
2899 if (r < 0)
2900 log_unit_debug_errno(u, r, "Failed to parse serialized restart counter '%s': %m", value);
2901
2902 } else if (streq(key, "flush-n-restarts")) {
2903 r = parse_boolean(value);
2904 if (r < 0)
2905 log_unit_debug_errno(u, r, "Failed to parse serialized flush restart counter setting '%s': %m", value);
2906 else
2907 s->flush_n_restarts = r;
2908 } else
2909 log_unit_debug(u, "Unknown serialization key: %s", key);
2910
2911 return 0;
2912 }
2913
2914 _pure_ static UnitActiveState service_active_state(Unit *u) {
2915 const UnitActiveState *table;
2916
2917 assert(u);
2918
2919 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2920
2921 return table[SERVICE(u)->state];
2922 }
2923
2924 static const char *service_sub_state_to_string(Unit *u) {
2925 assert(u);
2926
2927 return service_state_to_string(SERVICE(u)->state);
2928 }
2929
2930 static bool service_may_gc(Unit *u) {
2931 Service *s = SERVICE(u);
2932
2933 assert(s);
2934
2935 /* Never clean up services that still have a process around, even if the service is formally dead. Note that
2936 * unit_may_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
2937 * have moved outside of the cgroup. */
2938
2939 if (main_pid_good(s) > 0 ||
2940 control_pid_good(s) > 0)
2941 return false;
2942
2943 return true;
2944 }
2945
2946 static int service_retry_pid_file(Service *s) {
2947 int r;
2948
2949 assert(s->pid_file);
2950 assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
2951
2952 r = service_load_pid_file(s, false);
2953 if (r < 0)
2954 return r;
2955
2956 service_unwatch_pid_file(s);
2957
2958 service_enter_running(s, SERVICE_SUCCESS);
2959 return 0;
2960 }
2961
2962 static int service_watch_pid_file(Service *s) {
2963 int r;
2964
2965 log_unit_debug(UNIT(s), "Setting watch for PID file %s", s->pid_file_pathspec->path);
2966
2967 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_inotify_io);
2968 if (r < 0)
2969 goto fail;
2970
2971 /* the pidfile might have appeared just before we set the watch */
2972 log_unit_debug(UNIT(s), "Trying to read PID file %s in case it changed", s->pid_file_pathspec->path);
2973 service_retry_pid_file(s);
2974
2975 return 0;
2976 fail:
2977 log_unit_error_errno(UNIT(s), r, "Failed to set a watch for PID file %s: %m", s->pid_file_pathspec->path);
2978 service_unwatch_pid_file(s);
2979 return r;
2980 }
2981
2982 static int service_demand_pid_file(Service *s) {
2983 PathSpec *ps;
2984
2985 assert(s->pid_file);
2986 assert(!s->pid_file_pathspec);
2987
2988 ps = new0(PathSpec, 1);
2989 if (!ps)
2990 return -ENOMEM;
2991
2992 ps->unit = UNIT(s);
2993 ps->path = strdup(s->pid_file);
2994 if (!ps->path) {
2995 free(ps);
2996 return -ENOMEM;
2997 }
2998
2999 path_simplify(ps->path, false);
3000
3001 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
3002 * keep their PID file open all the time. */
3003 ps->type = PATH_MODIFIED;
3004 ps->inotify_fd = -1;
3005
3006 s->pid_file_pathspec = ps;
3007
3008 return service_watch_pid_file(s);
3009 }
3010
3011 static int service_dispatch_inotify_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
3012 PathSpec *p = userdata;
3013 Service *s;
3014
3015 assert(p);
3016
3017 s = SERVICE(p->unit);
3018
3019 assert(s);
3020 assert(fd >= 0);
3021 assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
3022 assert(s->pid_file_pathspec);
3023 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3024
3025 log_unit_debug(UNIT(s), "inotify event");
3026
3027 if (path_spec_fd_event(p, events) < 0)
3028 goto fail;
3029
3030 if (service_retry_pid_file(s) == 0)
3031 return 0;
3032
3033 if (service_watch_pid_file(s) < 0)
3034 goto fail;
3035
3036 return 0;
3037
3038 fail:
3039 service_unwatch_pid_file(s);
3040 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3041 return 0;
3042 }
3043
3044 static int service_dispatch_exec_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
3045 Service *s = SERVICE(userdata);
3046
3047 assert(s);
3048
3049 log_unit_debug(UNIT(s), "got exec-fd event");
3050
3051 /* If Type=exec is set, we'll consider a service started successfully the instant we invoked execve()
3052 * successfully for it. We implement this through a pipe() towards the child, which the kernel automatically
3053 * closes for us due to O_CLOEXEC on execve() in the child, which then triggers EOF on the pipe in the
3054 * parent. We need to be careful however, as there are other reasons that we might cause the child's side of
3055 * the pipe to be closed (for example, a simple exit()). To deal with that we'll ignore EOFs on the pipe unless
3056 * the child signalled us first that it is about to call the execve(). It does so by sending us a simple
3057 * non-zero byte via the pipe. We also provide the child with a way to inform us in case execve() failed: if it
3058 * sends a zero byte we'll ignore POLLHUP on the fd again. */
3059
3060 for (;;) {
3061 uint8_t x;
3062 ssize_t n;
3063
3064 n = read(fd, &x, sizeof(x));
3065 if (n < 0) {
3066 if (errno == EAGAIN) /* O_NONBLOCK in effect → everything queued has now been processed. */
3067 return 0;
3068
3069 return log_unit_error_errno(UNIT(s), errno, "Failed to read from exec_fd: %m");
3070 }
3071 if (n == 0) { /* EOF → the event we are waiting for */
3072
3073 s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
3074
3075 if (s->exec_fd_hot) { /* Did the child tell us to expect EOF now? */
3076 log_unit_debug(UNIT(s), "Got EOF on exec-fd");
3077
3078 s->exec_fd_hot = false;
3079
3080 /* Nice! This is what we have been waiting for. Transition to next state. */
3081 if (s->type == SERVICE_EXEC && s->state == SERVICE_START)
3082 service_enter_start_post(s);
3083 } else
3084 log_unit_debug(UNIT(s), "Got EOF on exec-fd while it was disabled, ignoring.");
3085
3086 return 0;
3087 }
3088
3089 /* A byte was read → this turns on/off the exec fd logic */
3090 assert(n == sizeof(x));
3091 s->exec_fd_hot = x;
3092 }
3093
3094 return 0;
3095 }
3096
3097 static void service_notify_cgroup_empty_event(Unit *u) {
3098 Service *s = SERVICE(u);
3099
3100 assert(u);
3101
3102 log_unit_debug(u, "cgroup is empty");
3103
3104 switch (s->state) {
3105
3106 /* Waiting for SIGCHLD is usually more interesting,
3107 * because it includes return codes/signals. Which is
3108 * why we ignore the cgroup events for most cases,
3109 * except when we don't know pid which to expect the
3110 * SIGCHLD for. */
3111
3112 case SERVICE_START:
3113 if (s->type == SERVICE_NOTIFY &&
3114 main_pid_good(s) == 0 &&
3115 control_pid_good(s) == 0) {
3116 /* No chance of getting a ready notification anymore */
3117 service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
3118 break;
3119 }
3120
3121 _fallthrough_;
3122 case SERVICE_START_POST:
3123 if (s->pid_file_pathspec &&
3124 main_pid_good(s) == 0 &&
3125 control_pid_good(s) == 0) {
3126
3127 /* Give up hoping for the daemon to write its PID file */
3128 log_unit_warning(u, "Daemon never wrote its PID file. Failing.");
3129
3130 service_unwatch_pid_file(s);
3131 if (s->state == SERVICE_START)
3132 service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
3133 else
3134 service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
3135 }
3136 break;
3137
3138 case SERVICE_RUNNING:
3139 /* service_enter_running() will figure out what to do */
3140 service_enter_running(s, SERVICE_SUCCESS);
3141 break;
3142
3143 case SERVICE_STOP_WATCHDOG:
3144 case SERVICE_STOP_SIGTERM:
3145 case SERVICE_STOP_SIGKILL:
3146
3147 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3148 service_enter_stop_post(s, SERVICE_SUCCESS);
3149
3150 break;
3151
3152 case SERVICE_STOP_POST:
3153 case SERVICE_FINAL_SIGTERM:
3154 case SERVICE_FINAL_SIGKILL:
3155 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3156 service_enter_dead(s, SERVICE_SUCCESS, true);
3157
3158 break;
3159
3160 default:
3161 ;
3162 }
3163 }
3164
3165 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
3166 bool notify_dbus = true;
3167 Service *s = SERVICE(u);
3168 ServiceResult f;
3169
3170 assert(s);
3171 assert(pid >= 0);
3172
3173 if (is_clean_exit(code, status, s->type == SERVICE_ONESHOT ? EXIT_CLEAN_COMMAND : EXIT_CLEAN_DAEMON, &s->success_status))
3174 f = SERVICE_SUCCESS;
3175 else if (code == CLD_EXITED)
3176 f = SERVICE_FAILURE_EXIT_CODE;
3177 else if (code == CLD_KILLED)
3178 f = SERVICE_FAILURE_SIGNAL;
3179 else if (code == CLD_DUMPED)
3180 f = SERVICE_FAILURE_CORE_DUMP;
3181 else
3182 assert_not_reached("Unknown code");
3183
3184 if (s->main_pid == pid) {
3185 /* Forking services may occasionally move to a new PID.
3186 * As long as they update the PID file before exiting the old
3187 * PID, they're fine. */
3188 if (service_load_pid_file(s, false) > 0)
3189 return;
3190
3191 s->main_pid = 0;
3192 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
3193
3194 if (s->main_command) {
3195 /* If this is not a forking service than the
3196 * main process got started and hence we copy
3197 * the exit status so that it is recorded both
3198 * as main and as control process exit
3199 * status */
3200
3201 s->main_command->exec_status = s->main_exec_status;
3202
3203 if (s->main_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3204 f = SERVICE_SUCCESS;
3205 } else if (s->exec_command[SERVICE_EXEC_START]) {
3206
3207 /* If this is a forked process, then we should
3208 * ignore the return value if this was
3209 * configured for the starter process */
3210
3211 if (s->exec_command[SERVICE_EXEC_START]->flags & EXEC_COMMAND_IGNORE_FAILURE)
3212 f = SERVICE_SUCCESS;
3213 }
3214
3215 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
3216 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
3217 * that the service already logged the reason at a higher log level on its own. However, if the service
3218 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
3219 * our log level to WARNING then. */
3220
3221 log_struct(f == SERVICE_SUCCESS ? LOG_DEBUG :
3222 (code == CLD_EXITED ? LOG_NOTICE : LOG_WARNING),
3223 LOG_UNIT_MESSAGE(u, "Main process exited, code=%s, status=%i/%s",
3224 sigchld_code_to_string(code), status,
3225 strna(code == CLD_EXITED
3226 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3227 : signal_to_string(status))),
3228 "EXIT_CODE=%s", sigchld_code_to_string(code),
3229 "EXIT_STATUS=%i", status,
3230 LOG_UNIT_ID(u),
3231 LOG_UNIT_INVOCATION_ID(u));
3232
3233 if (s->result == SERVICE_SUCCESS)
3234 s->result = f;
3235
3236 if (s->main_command &&
3237 s->main_command->command_next &&
3238 s->type == SERVICE_ONESHOT &&
3239 f == SERVICE_SUCCESS) {
3240
3241 /* There is another command to *
3242 * execute, so let's do that. */
3243
3244 log_unit_debug(u, "Running next main command for state %s.", service_state_to_string(s->state));
3245 service_run_next_main(s);
3246
3247 } else {
3248
3249 /* The service exited, so the service is officially
3250 * gone. */
3251 s->main_command = NULL;
3252
3253 switch (s->state) {
3254
3255 case SERVICE_START_POST:
3256 case SERVICE_RELOAD:
3257 case SERVICE_STOP:
3258 /* Need to wait until the operation is
3259 * done */
3260 break;
3261
3262 case SERVICE_START:
3263 if (s->type == SERVICE_ONESHOT) {
3264 /* This was our main goal, so let's go on */
3265 if (f == SERVICE_SUCCESS)
3266 service_enter_start_post(s);
3267 else
3268 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3269 break;
3270 } else if (s->type == SERVICE_NOTIFY) {
3271 /* Only enter running through a notification, so that the
3272 * SERVICE_START state signifies that no ready notification
3273 * has been received */
3274 if (f != SERVICE_SUCCESS)
3275 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3276 else if (!s->remain_after_exit || s->notify_access == NOTIFY_MAIN)
3277 /* The service has never been and will never be active */
3278 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3279 break;
3280 }
3281
3282 _fallthrough_;
3283 case SERVICE_RUNNING:
3284 service_enter_running(s, f);
3285 break;
3286
3287 case SERVICE_STOP_WATCHDOG:
3288 case SERVICE_STOP_SIGTERM:
3289 case SERVICE_STOP_SIGKILL:
3290
3291 if (control_pid_good(s) <= 0)
3292 service_enter_stop_post(s, f);
3293
3294 /* If there is still a control process, wait for that first */
3295 break;
3296
3297 case SERVICE_STOP_POST:
3298 case SERVICE_FINAL_SIGTERM:
3299 case SERVICE_FINAL_SIGKILL:
3300
3301 if (control_pid_good(s) <= 0)
3302 service_enter_dead(s, f, true);
3303 break;
3304
3305 default:
3306 assert_not_reached("Uh, main process died at wrong time.");
3307 }
3308 }
3309
3310 } else if (s->control_pid == pid) {
3311 s->control_pid = 0;
3312
3313 if (s->control_command) {
3314 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
3315
3316 if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3317 f = SERVICE_SUCCESS;
3318 }
3319
3320 log_unit_full(u, f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
3321 "Control process exited, code=%s status=%i",
3322 sigchld_code_to_string(code), status);
3323
3324 if (s->result == SERVICE_SUCCESS)
3325 s->result = f;
3326
3327 if (s->control_command &&
3328 s->control_command->command_next &&
3329 f == SERVICE_SUCCESS) {
3330
3331 /* There is another command to *
3332 * execute, so let's do that. */
3333
3334 log_unit_debug(u, "Running next control command for state %s.", service_state_to_string(s->state));
3335 service_run_next_control(s);
3336
3337 } else {
3338 /* No further commands for this step, so let's
3339 * figure out what to do next */
3340
3341 s->control_command = NULL;
3342 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3343
3344 log_unit_debug(u, "Got final SIGCHLD for state %s.", service_state_to_string(s->state));
3345
3346 switch (s->state) {
3347
3348 case SERVICE_START_PRE:
3349 if (f == SERVICE_SUCCESS)
3350 service_enter_start(s);
3351 else
3352 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3353 break;
3354
3355 case SERVICE_START:
3356 if (s->type != SERVICE_FORKING)
3357 /* Maybe spurious event due to a reload that changed the type? */
3358 break;
3359
3360 if (f != SERVICE_SUCCESS) {
3361 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3362 break;
3363 }
3364
3365 if (s->pid_file) {
3366 bool has_start_post;
3367 int r;
3368
3369 /* Let's try to load the pid file here if we can.
3370 * The PID file might actually be created by a START_POST
3371 * script. In that case don't worry if the loading fails. */
3372
3373 has_start_post = s->exec_command[SERVICE_EXEC_START_POST];
3374 r = service_load_pid_file(s, !has_start_post);
3375 if (!has_start_post && r < 0) {
3376 r = service_demand_pid_file(s);
3377 if (r < 0 || cgroup_good(s) == 0)
3378 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3379 break;
3380 }
3381 } else
3382 service_search_main_pid(s);
3383
3384 service_enter_start_post(s);
3385 break;
3386
3387 case SERVICE_START_POST:
3388 if (f != SERVICE_SUCCESS) {
3389 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3390 break;
3391 }
3392
3393 if (s->pid_file) {
3394 int r;
3395
3396 r = service_load_pid_file(s, true);
3397 if (r < 0) {
3398 r = service_demand_pid_file(s);
3399 if (r < 0 || cgroup_good(s) == 0)
3400 service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
3401 break;
3402 }
3403 } else
3404 service_search_main_pid(s);
3405
3406 service_enter_running(s, SERVICE_SUCCESS);
3407 break;
3408
3409 case SERVICE_RELOAD:
3410 if (f == SERVICE_SUCCESS)
3411 if (service_load_pid_file(s, true) < 0)
3412 service_search_main_pid(s);
3413
3414 s->reload_result = f;
3415 service_enter_running(s, SERVICE_SUCCESS);
3416 break;
3417
3418 case SERVICE_STOP:
3419 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3420 break;
3421
3422 case SERVICE_STOP_WATCHDOG:
3423 case SERVICE_STOP_SIGTERM:
3424 case SERVICE_STOP_SIGKILL:
3425 if (main_pid_good(s) <= 0)
3426 service_enter_stop_post(s, f);
3427
3428 /* If there is still a service
3429 * process around, wait until
3430 * that one quit, too */
3431 break;
3432
3433 case SERVICE_STOP_POST:
3434 case SERVICE_FINAL_SIGTERM:
3435 case SERVICE_FINAL_SIGKILL:
3436 if (main_pid_good(s) <= 0)
3437 service_enter_dead(s, f, true);
3438 break;
3439
3440 default:
3441 assert_not_reached("Uh, control process died at wrong time.");
3442 }
3443 }
3444 } else /* Neither control nor main PID? If so, don't notify about anything */
3445 notify_dbus = false;
3446
3447 /* Notify clients about changed exit status */
3448 if (notify_dbus)
3449 unit_add_to_dbus_queue(u);
3450
3451 /* If we get a SIGCHLD event for one of the processes we were interested in, then we look for others to watch,
3452 * under the assumption that we'll sooner or later get a SIGCHLD for them, as the original process we watched
3453 * was probably the parent of them, and they are hence now our children. */
3454 (void) unit_enqueue_rewatch_pids(u);
3455 }
3456
3457 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3458 Service *s = SERVICE(userdata);
3459
3460 assert(s);
3461 assert(source == s->timer_event_source);
3462
3463 switch (s->state) {
3464
3465 case SERVICE_START_PRE:
3466 case SERVICE_START:
3467 log_unit_warning(UNIT(s), "%s operation timed out. Terminating.", s->state == SERVICE_START ? "Start" : "Start-pre");
3468 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3469 break;
3470
3471 case SERVICE_START_POST:
3472 log_unit_warning(UNIT(s), "Start-post operation timed out. Stopping.");
3473 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3474 break;
3475
3476 case SERVICE_RUNNING:
3477 log_unit_warning(UNIT(s), "Service reached runtime time limit. Stopping.");
3478 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3479 break;
3480
3481 case SERVICE_RELOAD:
3482 log_unit_warning(UNIT(s), "Reload operation timed out. Killing reload process.");
3483 service_kill_control_process(s);
3484 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3485 service_enter_running(s, SERVICE_SUCCESS);
3486 break;
3487
3488 case SERVICE_STOP:
3489 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
3490 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3491 break;
3492
3493 case SERVICE_STOP_WATCHDOG:
3494 log_unit_warning(UNIT(s), "State 'stop-watchdog' timed out. Terminating.");
3495 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3496 break;
3497
3498 case SERVICE_STOP_SIGTERM:
3499 if (s->kill_context.send_sigkill) {
3500 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Killing.");
3501 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3502 } else {
3503 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3504 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3505 }
3506
3507 break;
3508
3509 case SERVICE_STOP_SIGKILL:
3510 /* Uh, we sent a SIGKILL and it is still not gone?
3511 * Must be something we cannot kill, so let's just be
3512 * weirded out and continue */
3513
3514 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
3515 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3516 break;
3517
3518 case SERVICE_STOP_POST:
3519 log_unit_warning(UNIT(s), "State 'stop-post' timed out. Terminating.");
3520 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3521 break;
3522
3523 case SERVICE_FINAL_SIGTERM:
3524 if (s->kill_context.send_sigkill) {
3525 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Killing.");
3526 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3527 } else {
3528 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3529 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3530 }
3531
3532 break;
3533
3534 case SERVICE_FINAL_SIGKILL:
3535 log_unit_warning(UNIT(s), "Processes still around after final SIGKILL. Entering failed mode.");
3536 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3537 break;
3538
3539 case SERVICE_AUTO_RESTART:
3540 if (s->restart_usec > 0) {
3541 char buf_restart[FORMAT_TIMESPAN_MAX];
3542 log_unit_info(UNIT(s),
3543 "Service RestartSec=%s expired, scheduling restart.",
3544 format_timespan(buf_restart, sizeof buf_restart, s->restart_usec, USEC_PER_SEC));
3545 } else
3546 log_unit_info(UNIT(s),
3547 "Service has no hold-off time (RestartSec=0), scheduling restart.");
3548
3549 service_enter_restart(s);
3550 break;
3551
3552 default:
3553 assert_not_reached("Timeout at wrong time.");
3554 }
3555
3556 return 0;
3557 }
3558
3559 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3560 Service *s = SERVICE(userdata);
3561 char t[FORMAT_TIMESPAN_MAX];
3562 usec_t watchdog_usec;
3563
3564 assert(s);
3565 assert(source == s->watchdog_event_source);
3566
3567 watchdog_usec = service_get_watchdog_usec(s);
3568
3569 if (UNIT(s)->manager->service_watchdogs) {
3570 log_unit_error(UNIT(s), "Watchdog timeout (limit %s)!",
3571 format_timespan(t, sizeof(t), watchdog_usec, 1));
3572
3573 service_enter_signal(s, SERVICE_STOP_WATCHDOG, SERVICE_FAILURE_WATCHDOG);
3574 } else
3575 log_unit_warning(UNIT(s), "Watchdog disabled! Ignoring watchdog timeout (limit %s)!",
3576 format_timespan(t, sizeof(t), watchdog_usec, 1));
3577
3578 return 0;
3579 }
3580
3581 static bool service_notify_message_authorized(Service *s, pid_t pid, char **tags, FDSet *fds) {
3582 assert(s);
3583
3584 if (s->notify_access == NOTIFY_NONE) {
3585 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception is disabled.", pid);
3586 return false;
3587 }
3588
3589 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3590 if (s->main_pid != 0)
3591 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, pid, s->main_pid);
3592 else
3593 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", pid);
3594
3595 return false;
3596 }
3597
3598 if (s->notify_access == NOTIFY_EXEC && pid != s->main_pid && pid != s->control_pid) {
3599 if (s->main_pid != 0 && s->control_pid != 0)
3600 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT" and control PID "PID_FMT,
3601 pid, s->main_pid, s->control_pid);
3602 else if (s->main_pid != 0)
3603 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, pid, s->main_pid);
3604 else if (s->control_pid != 0)
3605 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for control PID "PID_FMT, pid, s->control_pid);
3606 else
3607 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID and control PID which are currently not known", pid);
3608
3609 return false;
3610 }
3611
3612 return true;
3613 }
3614
3615 static void service_notify_message(
3616 Unit *u,
3617 const struct ucred *ucred,
3618 char **tags,
3619 FDSet *fds) {
3620
3621 Service *s = SERVICE(u);
3622 bool notify_dbus = false;
3623 const char *e;
3624 char **i;
3625 int r;
3626
3627 assert(u);
3628 assert(ucred);
3629
3630 if (!service_notify_message_authorized(SERVICE(u), ucred->pid, tags, fds))
3631 return;
3632
3633 if (DEBUG_LOGGING) {
3634 _cleanup_free_ char *cc = NULL;
3635
3636 cc = strv_join(tags, ", ");
3637 log_unit_debug(u, "Got notification message from PID "PID_FMT" (%s)", ucred->pid, isempty(cc) ? "n/a" : cc);
3638 }
3639
3640 /* Interpret MAINPID= */
3641 e = strv_find_startswith(tags, "MAINPID=");
3642 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
3643 pid_t new_main_pid;
3644
3645 if (parse_pid(e, &new_main_pid) < 0)
3646 log_unit_warning(u, "Failed to parse MAINPID= field in notification message, ignoring: %s", e);
3647 else if (!s->main_pid_known || new_main_pid != s->main_pid) {
3648
3649 r = service_is_suitable_main_pid(s, new_main_pid, LOG_WARNING);
3650 if (r == 0) {
3651 /* The new main PID is a bit suspicous, which is OK if the sender is privileged. */
3652
3653 if (ucred->uid == 0) {
3654 log_unit_debug(u, "New main PID "PID_FMT" does not belong to service, but we'll accept it as the request to change it came from a privileged process.", new_main_pid);
3655 r = 1;
3656 } else
3657 log_unit_debug(u, "New main PID "PID_FMT" does not belong to service, refusing.", new_main_pid);
3658 }
3659 if (r > 0) {
3660 service_set_main_pid(s, new_main_pid);
3661
3662 r = unit_watch_pid(UNIT(s), new_main_pid);
3663 if (r < 0)
3664 log_unit_warning_errno(UNIT(s), r, "Failed to watch new main PID "PID_FMT" for service: %m", new_main_pid);
3665
3666 notify_dbus = true;
3667 }
3668 }
3669 }
3670
3671 /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3672 STRV_FOREACH_BACKWARDS(i, tags) {
3673
3674 if (streq(*i, "READY=1")) {
3675 s->notify_state = NOTIFY_READY;
3676
3677 /* Type=notify services inform us about completed
3678 * initialization with READY=1 */
3679 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
3680 service_enter_start_post(s);
3681
3682 /* Sending READY=1 while we are reloading informs us
3683 * that the reloading is complete */
3684 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
3685 service_enter_running(s, SERVICE_SUCCESS);
3686
3687 notify_dbus = true;
3688 break;
3689
3690 } else if (streq(*i, "RELOADING=1")) {
3691 s->notify_state = NOTIFY_RELOADING;
3692
3693 if (s->state == SERVICE_RUNNING)
3694 service_enter_reload_by_notify(s);
3695
3696 notify_dbus = true;
3697 break;
3698
3699 } else if (streq(*i, "STOPPING=1")) {
3700 s->notify_state = NOTIFY_STOPPING;
3701
3702 if (s->state == SERVICE_RUNNING)
3703 service_enter_stop_by_notify(s);
3704
3705 notify_dbus = true;
3706 break;
3707 }
3708 }
3709
3710 /* Interpret STATUS= */
3711 e = strv_find_startswith(tags, "STATUS=");
3712 if (e) {
3713 _cleanup_free_ char *t = NULL;
3714
3715 if (!isempty(e)) {
3716 /* Note that this size limit check is mostly paranoia: since the datagram size we are willing
3717 * to process is already limited to NOTIFY_BUFFER_MAX, this limit here should never be hit. */
3718 if (strlen(e) > STATUS_TEXT_MAX)
3719 log_unit_warning(u, "Status message overly long (%zu > %u), ignoring.", strlen(e), STATUS_TEXT_MAX);
3720 else if (!utf8_is_valid(e))
3721 log_unit_warning(u, "Status message in notification message is not UTF-8 clean, ignoring.");
3722 else {
3723 t = strdup(e);
3724 if (!t)
3725 log_oom();
3726 }
3727 }
3728
3729 if (!streq_ptr(s->status_text, t)) {
3730 free_and_replace(s->status_text, t);
3731 notify_dbus = true;
3732 }
3733 }
3734
3735 /* Interpret ERRNO= */
3736 e = strv_find_startswith(tags, "ERRNO=");
3737 if (e) {
3738 int status_errno;
3739
3740 status_errno = parse_errno(e);
3741 if (status_errno < 0)
3742 log_unit_warning_errno(u, status_errno,
3743 "Failed to parse ERRNO= field value '%s' in notification message: %m", e);
3744 else if (s->status_errno != status_errno) {
3745 s->status_errno = status_errno;
3746 notify_dbus = true;
3747 }
3748 }
3749
3750 /* Interpret EXTEND_TIMEOUT= */
3751 e = strv_find_startswith(tags, "EXTEND_TIMEOUT_USEC=");
3752 if (e) {
3753 usec_t extend_timeout_usec;
3754 if (safe_atou64(e, &extend_timeout_usec) < 0)
3755 log_unit_warning(u, "Failed to parse EXTEND_TIMEOUT_USEC=%s", e);
3756 else
3757 service_extend_timeout(s, extend_timeout_usec);
3758 }
3759
3760 /* Interpret WATCHDOG= */
3761 if (strv_find(tags, "WATCHDOG=1"))
3762 service_reset_watchdog(s);
3763
3764 e = strv_find_startswith(tags, "WATCHDOG_USEC=");
3765 if (e) {
3766 usec_t watchdog_override_usec;
3767 if (safe_atou64(e, &watchdog_override_usec) < 0)
3768 log_unit_warning(u, "Failed to parse WATCHDOG_USEC=%s", e);
3769 else
3770 service_reset_watchdog_timeout(s, watchdog_override_usec);
3771 }
3772
3773 /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
3774 * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
3775 * fds, but optional when pushing in new fds, for compatibility reasons. */
3776 if (strv_find(tags, "FDSTOREREMOVE=1")) {
3777 const char *name;
3778
3779 name = strv_find_startswith(tags, "FDNAME=");
3780 if (!name || !fdname_is_valid(name))
3781 log_unit_warning(u, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
3782 else
3783 service_remove_fd_store(s, name);
3784
3785 } else if (strv_find(tags, "FDSTORE=1")) {
3786 const char *name;
3787
3788 name = strv_find_startswith(tags, "FDNAME=");
3789 if (name && !fdname_is_valid(name)) {
3790 log_unit_warning(u, "Passed FDNAME= name is invalid, ignoring.");
3791 name = NULL;
3792 }
3793
3794 (void) service_add_fd_store_set(s, fds, name);
3795 }
3796
3797 /* Notify clients about changed status or main pid */
3798 if (notify_dbus)
3799 unit_add_to_dbus_queue(u);
3800 }
3801
3802 static int service_get_timeout(Unit *u, usec_t *timeout) {
3803 Service *s = SERVICE(u);
3804 uint64_t t;
3805 int r;
3806
3807 if (!s->timer_event_source)
3808 return 0;
3809
3810 r = sd_event_source_get_time(s->timer_event_source, &t);
3811 if (r < 0)
3812 return r;
3813 if (t == USEC_INFINITY)
3814 return 0;
3815
3816 *timeout = t;
3817 return 1;
3818 }
3819
3820 static void service_bus_name_owner_change(
3821 Unit *u,
3822 const char *name,
3823 const char *old_owner,
3824 const char *new_owner) {
3825
3826 Service *s = SERVICE(u);
3827 int r;
3828
3829 assert(s);
3830 assert(name);
3831
3832 assert(streq(s->bus_name, name));
3833 assert(old_owner || new_owner);
3834
3835 if (old_owner && new_owner)
3836 log_unit_debug(u, "D-Bus name %s changed owner from %s to %s", name, old_owner, new_owner);
3837 else if (old_owner)
3838 log_unit_debug(u, "D-Bus name %s no longer registered by %s", name, old_owner);
3839 else
3840 log_unit_debug(u, "D-Bus name %s now registered by %s", name, new_owner);
3841
3842 s->bus_name_good = !!new_owner;
3843
3844 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3845 r = free_and_strdup(&s->bus_name_owner, new_owner);
3846 if (r < 0) {
3847 log_unit_error_errno(u, r, "Unable to set new bus name owner %s: %m", new_owner);
3848 return;
3849 }
3850
3851 if (s->type == SERVICE_DBUS) {
3852
3853 /* service_enter_running() will figure out what to
3854 * do */
3855 if (s->state == SERVICE_RUNNING)
3856 service_enter_running(s, SERVICE_SUCCESS);
3857 else if (s->state == SERVICE_START && new_owner)
3858 service_enter_start_post(s);
3859
3860 } else if (new_owner &&
3861 s->main_pid <= 0 &&
3862 IN_SET(s->state,
3863 SERVICE_START,
3864 SERVICE_START_POST,
3865 SERVICE_RUNNING,
3866 SERVICE_RELOAD)) {
3867
3868 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
3869 pid_t pid;
3870
3871 /* Try to acquire PID from bus service */
3872
3873 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3874 if (r >= 0)
3875 r = sd_bus_creds_get_pid(creds, &pid);
3876 if (r >= 0) {
3877 log_unit_debug(u, "D-Bus name %s is now owned by process " PID_FMT, name, pid);
3878
3879 service_set_main_pid(s, pid);
3880 unit_watch_pid(UNIT(s), pid);
3881 }
3882 }
3883 }
3884
3885 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
3886 _cleanup_free_ char *peer = NULL;
3887 int r;
3888
3889 assert(s);
3890 assert(fd >= 0);
3891
3892 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3893 * to be configured. We take ownership of the passed fd on success. */
3894
3895 if (UNIT(s)->load_state != UNIT_LOADED)
3896 return -EINVAL;
3897
3898 if (s->socket_fd >= 0)
3899 return -EBUSY;
3900
3901 if (s->state != SERVICE_DEAD)
3902 return -EAGAIN;
3903
3904 if (getpeername_pretty(fd, true, &peer) >= 0) {
3905
3906 if (UNIT(s)->description) {
3907 _cleanup_free_ char *a;
3908
3909 a = strjoin(UNIT(s)->description, " (", peer, ")");
3910 if (!a)
3911 return -ENOMEM;
3912
3913 r = unit_set_description(UNIT(s), a);
3914 } else
3915 r = unit_set_description(UNIT(s), peer);
3916
3917 if (r < 0)
3918 return r;
3919 }
3920
3921 r = unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false, UNIT_DEPENDENCY_IMPLICIT);
3922 if (r < 0)
3923 return r;
3924
3925 s->socket_fd = fd;
3926 s->socket_fd_selinux_context_net = selinux_context_net;
3927
3928 unit_ref_set(&s->accept_socket, UNIT(s), UNIT(sock));
3929 return 0;
3930 }
3931
3932 static void service_reset_failed(Unit *u) {
3933 Service *s = SERVICE(u);
3934
3935 assert(s);
3936
3937 if (s->state == SERVICE_FAILED)
3938 service_set_state(s, SERVICE_DEAD);
3939
3940 s->result = SERVICE_SUCCESS;
3941 s->reload_result = SERVICE_SUCCESS;
3942 s->n_restarts = 0;
3943 s->flush_n_restarts = false;
3944 }
3945
3946 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3947 Service *s = SERVICE(u);
3948
3949 assert(s);
3950
3951 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3952 }
3953
3954 static int service_main_pid(Unit *u) {
3955 Service *s = SERVICE(u);
3956
3957 assert(s);
3958
3959 return s->main_pid;
3960 }
3961
3962 static int service_control_pid(Unit *u) {
3963 Service *s = SERVICE(u);
3964
3965 assert(s);
3966
3967 return s->control_pid;
3968 }
3969
3970 static bool service_needs_console(Unit *u) {
3971 Service *s = SERVICE(u);
3972
3973 assert(s);
3974
3975 /* We provide our own implementation of this here, instead of relying of the generic implementation
3976 * unit_needs_console() provides, since we want to return false if we are in SERVICE_EXITED state. */
3977
3978 if (!exec_context_may_touch_console(&s->exec_context))
3979 return false;
3980
3981 return IN_SET(s->state,
3982 SERVICE_START_PRE,
3983 SERVICE_START,
3984 SERVICE_START_POST,
3985 SERVICE_RUNNING,
3986 SERVICE_RELOAD,
3987 SERVICE_STOP,
3988 SERVICE_STOP_WATCHDOG,
3989 SERVICE_STOP_SIGTERM,
3990 SERVICE_STOP_SIGKILL,
3991 SERVICE_STOP_POST,
3992 SERVICE_FINAL_SIGTERM,
3993 SERVICE_FINAL_SIGKILL);
3994 }
3995
3996 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3997 [SERVICE_RESTART_NO] = "no",
3998 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3999 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
4000 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
4001 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
4002 [SERVICE_RESTART_ON_ABORT] = "on-abort",
4003 [SERVICE_RESTART_ALWAYS] = "always",
4004 };
4005
4006 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
4007
4008 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
4009 [SERVICE_SIMPLE] = "simple",
4010 [SERVICE_FORKING] = "forking",
4011 [SERVICE_ONESHOT] = "oneshot",
4012 [SERVICE_DBUS] = "dbus",
4013 [SERVICE_NOTIFY] = "notify",
4014 [SERVICE_IDLE] = "idle",
4015 [SERVICE_EXEC] = "exec",
4016 };
4017
4018 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
4019
4020 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
4021 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
4022 [SERVICE_EXEC_START] = "ExecStart",
4023 [SERVICE_EXEC_START_POST] = "ExecStartPost",
4024 [SERVICE_EXEC_RELOAD] = "ExecReload",
4025 [SERVICE_EXEC_STOP] = "ExecStop",
4026 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
4027 };
4028
4029 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
4030
4031 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
4032 [NOTIFY_UNKNOWN] = "unknown",
4033 [NOTIFY_READY] = "ready",
4034 [NOTIFY_RELOADING] = "reloading",
4035 [NOTIFY_STOPPING] = "stopping",
4036 };
4037
4038 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
4039
4040 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
4041 [SERVICE_SUCCESS] = "success",
4042 [SERVICE_FAILURE_RESOURCES] = "resources",
4043 [SERVICE_FAILURE_PROTOCOL] = "protocol",
4044 [SERVICE_FAILURE_TIMEOUT] = "timeout",
4045 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
4046 [SERVICE_FAILURE_SIGNAL] = "signal",
4047 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
4048 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
4049 [SERVICE_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
4050 };
4051
4052 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
4053
4054 const UnitVTable service_vtable = {
4055 .object_size = sizeof(Service),
4056 .exec_context_offset = offsetof(Service, exec_context),
4057 .cgroup_context_offset = offsetof(Service, cgroup_context),
4058 .kill_context_offset = offsetof(Service, kill_context),
4059 .exec_runtime_offset = offsetof(Service, exec_runtime),
4060 .dynamic_creds_offset = offsetof(Service, dynamic_creds),
4061
4062 .sections =
4063 "Unit\0"
4064 "Service\0"
4065 "Install\0",
4066 .private_section = "Service",
4067
4068 .can_transient = true,
4069 .can_delegate = true,
4070
4071 .init = service_init,
4072 .done = service_done,
4073 .load = service_load,
4074 .release_resources = service_release_resources,
4075
4076 .coldplug = service_coldplug,
4077
4078 .dump = service_dump,
4079
4080 .start = service_start,
4081 .stop = service_stop,
4082 .reload = service_reload,
4083
4084 .can_reload = service_can_reload,
4085
4086 .kill = service_kill,
4087
4088 .serialize = service_serialize,
4089 .deserialize_item = service_deserialize_item,
4090
4091 .active_state = service_active_state,
4092 .sub_state_to_string = service_sub_state_to_string,
4093
4094 .will_restart = service_will_restart,
4095
4096 .may_gc = service_may_gc,
4097
4098 .sigchld_event = service_sigchld_event,
4099
4100 .reset_failed = service_reset_failed,
4101
4102 .notify_cgroup_empty = service_notify_cgroup_empty_event,
4103 .notify_message = service_notify_message,
4104
4105 .main_pid = service_main_pid,
4106 .control_pid = service_control_pid,
4107
4108 .bus_name_owner_change = service_bus_name_owner_change,
4109
4110 .bus_vtable = bus_service_vtable,
4111 .bus_set_property = bus_service_set_property,
4112 .bus_commit_properties = bus_service_commit_properties,
4113
4114 .get_timeout = service_get_timeout,
4115 .needs_console = service_needs_console,
4116
4117 .status_message_formats = {
4118 .starting_stopping = {
4119 [0] = "Starting %s...",
4120 [1] = "Stopping %s...",
4121 },
4122 .finished_start_job = {
4123 [JOB_DONE] = "Started %s.",
4124 [JOB_FAILED] = "Failed to start %s.",
4125 },
4126 .finished_stop_job = {
4127 [JOB_DONE] = "Stopped %s.",
4128 [JOB_FAILED] = "Stopped (with error) %s.",
4129 },
4130 },
4131 };
Unnamed repository; edit this file 'description' to name the repository.