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