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