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