]> 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
Merge pull request #8656 from yuwata/random-fixes
[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 = TAKE_PTR(cfds);
1254 rn_socket_fds = cn_fds;
1255 } else {
1256 int *t;
1257
1258 t = reallocarray(rfds, rn_socket_fds + cn_fds, sizeof(int));
1259 if (!t)
1260 return -ENOMEM;
1261
1262 memcpy(t + rn_socket_fds, cfds, cn_fds * sizeof(int));
1263
1264 rfds = t;
1265 rn_socket_fds += cn_fds;
1266 }
1267
1268 r = strv_extend_n(&rfd_names, socket_fdname(sock), cn_fds);
1269 if (r < 0)
1270 return r;
1271 }
1272 }
1273
1274 if (s->n_fd_store > 0) {
1275 ServiceFDStore *fs;
1276 unsigned n_fds;
1277 char **nl;
1278 int *t;
1279
1280 t = reallocarray(rfds, rn_socket_fds + s->n_fd_store, sizeof(int));
1281 if (!t)
1282 return -ENOMEM;
1283
1284 rfds = t;
1285
1286 nl = reallocarray(rfd_names, rn_socket_fds + s->n_fd_store + 1, sizeof(char *));
1287 if (!nl)
1288 return -ENOMEM;
1289
1290 rfd_names = nl;
1291 n_fds = rn_socket_fds;
1292
1293 LIST_FOREACH(fd_store, fs, s->fd_store) {
1294 rfds[n_fds] = fs->fd;
1295 rfd_names[n_fds] = strdup(strempty(fs->fdname));
1296 if (!rfd_names[n_fds])
1297 return -ENOMEM;
1298
1299 rn_storage_fds++;
1300 n_fds++;
1301 }
1302
1303 rfd_names[n_fds] = NULL;
1304 }
1305
1306 *fds = TAKE_PTR(rfds);
1307 *fd_names = TAKE_PTR(rfd_names);
1308 *n_socket_fds = rn_socket_fds;
1309 *n_storage_fds = rn_storage_fds;
1310
1311 return 0;
1312 }
1313
1314 static bool service_exec_needs_notify_socket(Service *s, ExecFlags flags) {
1315 assert(s);
1316
1317 /* Notifications are accepted depending on the process and
1318 * the access setting of the service:
1319 * process: \ access: NONE MAIN EXEC ALL
1320 * main no yes yes yes
1321 * control no no yes yes
1322 * other (forked) no no no yes */
1323
1324 if (flags & EXEC_IS_CONTROL)
1325 /* A control process */
1326 return IN_SET(s->notify_access, NOTIFY_EXEC, NOTIFY_ALL);
1327
1328 /* We only spawn main processes and control processes, so any
1329 * process that is not a control process is a main process */
1330 return s->notify_access != NOTIFY_NONE;
1331 }
1332
1333 static int service_spawn(
1334 Service *s,
1335 ExecCommand *c,
1336 usec_t timeout,
1337 ExecFlags flags,
1338 pid_t *_pid) {
1339
1340 ExecParameters exec_params = {
1341 .flags = flags,
1342 .stdin_fd = -1,
1343 .stdout_fd = -1,
1344 .stderr_fd = -1,
1345 };
1346 _cleanup_strv_free_ char **final_env = NULL, **our_env = NULL, **fd_names = NULL;
1347 unsigned n_storage_fds = 0, n_socket_fds = 0, n_env = 0;
1348 _cleanup_free_ int *fds = NULL;
1349 pid_t pid;
1350 int r;
1351
1352 assert(s);
1353 assert(c);
1354 assert(_pid);
1355
1356 r = unit_prepare_exec(UNIT(s));
1357 if (r < 0)
1358 return r;
1359
1360 if (flags & EXEC_IS_CONTROL) {
1361 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1362 if (s->permissions_start_only)
1363 exec_params.flags &= ~EXEC_APPLY_SANDBOXING;
1364 if (s->root_directory_start_only)
1365 exec_params.flags &= ~EXEC_APPLY_CHROOT;
1366 }
1367
1368 if ((flags & EXEC_PASS_FDS) ||
1369 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1370 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1371 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1372
1373 r = service_collect_fds(s, &fds, &fd_names, &n_storage_fds, &n_socket_fds);
1374 if (r < 0)
1375 return r;
1376
1377 log_unit_debug(UNIT(s), "Passing %i fds to service", n_storage_fds + n_socket_fds);
1378 }
1379
1380 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), timeout));
1381 if (r < 0)
1382 return r;
1383
1384 our_env = new0(char*, 9);
1385 if (!our_env)
1386 return -ENOMEM;
1387
1388 if (service_exec_needs_notify_socket(s, flags))
1389 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0)
1390 return -ENOMEM;
1391
1392 if (s->main_pid > 0)
1393 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0)
1394 return -ENOMEM;
1395
1396 if (MANAGER_IS_USER(UNIT(s)->manager))
1397 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid_cached()) < 0)
1398 return -ENOMEM;
1399
1400 if (s->socket_fd >= 0) {
1401 union sockaddr_union sa;
1402 socklen_t salen = sizeof(sa);
1403
1404 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1405 * useful. Note that we do this only when we are still connected at this point in time, which we might
1406 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1407 * in ENOTCONN), and just use whate we can use. */
1408
1409 if (getpeername(s->socket_fd, &sa.sa, &salen) >= 0 &&
1410 IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
1411
1412 _cleanup_free_ char *addr = NULL;
1413 char *t;
1414 unsigned port;
1415
1416 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1417 if (r < 0)
1418 return r;
1419
1420 t = strappend("REMOTE_ADDR=", addr);
1421 if (!t)
1422 return -ENOMEM;
1423 our_env[n_env++] = t;
1424
1425 r = sockaddr_port(&sa.sa, &port);
1426 if (r < 0)
1427 return r;
1428
1429 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
1430 return -ENOMEM;
1431 our_env[n_env++] = t;
1432 }
1433 }
1434
1435 if (flags & EXEC_SETENV_RESULT) {
1436 if (asprintf(our_env + n_env++, "SERVICE_RESULT=%s", service_result_to_string(s->result)) < 0)
1437 return -ENOMEM;
1438
1439 if (s->main_exec_status.pid > 0 &&
1440 dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1441 if (asprintf(our_env + n_env++, "EXIT_CODE=%s", sigchld_code_to_string(s->main_exec_status.code)) < 0)
1442 return -ENOMEM;
1443
1444 if (s->main_exec_status.code == CLD_EXITED)
1445 r = asprintf(our_env + n_env++, "EXIT_STATUS=%i", s->main_exec_status.status);
1446 else
1447 r = asprintf(our_env + n_env++, "EXIT_STATUS=%s", signal_to_string(s->main_exec_status.status));
1448 if (r < 0)
1449 return -ENOMEM;
1450 }
1451 }
1452
1453 unit_set_exec_params(UNIT(s), &exec_params);
1454
1455 final_env = strv_env_merge(2, exec_params.environment, our_env, NULL);
1456 if (!final_env)
1457 return -ENOMEM;
1458
1459 /* System services should get a new keyring by default. */
1460 SET_FLAG(exec_params.flags, EXEC_NEW_KEYRING, MANAGER_IS_SYSTEM(UNIT(s)->manager));
1461
1462 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1463 SET_FLAG(exec_params.flags, EXEC_NSS_BYPASS_BUS,
1464 MANAGER_IS_SYSTEM(UNIT(s)->manager) && unit_has_name(UNIT(s), SPECIAL_DBUS_SERVICE));
1465
1466 exec_params.argv = c->argv;
1467 exec_params.environment = final_env;
1468 exec_params.fds = fds;
1469 exec_params.fd_names = fd_names;
1470 exec_params.n_storage_fds = n_storage_fds;
1471 exec_params.n_socket_fds = n_socket_fds;
1472 exec_params.watchdog_usec = s->watchdog_usec;
1473 exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
1474 if (s->type == SERVICE_IDLE)
1475 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1476 exec_params.stdin_fd = s->stdin_fd;
1477 exec_params.stdout_fd = s->stdout_fd;
1478 exec_params.stderr_fd = s->stderr_fd;
1479
1480 r = exec_spawn(UNIT(s),
1481 c,
1482 &s->exec_context,
1483 &exec_params,
1484 s->exec_runtime,
1485 &s->dynamic_creds,
1486 &pid);
1487 if (r < 0)
1488 return r;
1489
1490 r = unit_watch_pid(UNIT(s), pid);
1491 if (r < 0) /* FIXME: we need to do something here */
1492 return r;
1493
1494 *_pid = pid;
1495
1496 return 0;
1497 }
1498
1499 static int main_pid_good(Service *s) {
1500 assert(s);
1501
1502 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1503
1504 /* If we know the pid file, then let's just check if it is
1505 * still valid */
1506 if (s->main_pid_known) {
1507
1508 /* If it's an alien child let's check if it is still
1509 * alive ... */
1510 if (s->main_pid_alien && s->main_pid > 0)
1511 return pid_is_alive(s->main_pid);
1512
1513 /* .. otherwise assume we'll get a SIGCHLD for it,
1514 * which we really should wait for to collect exit
1515 * status and code */
1516 return s->main_pid > 0;
1517 }
1518
1519 /* We don't know the pid */
1520 return -EAGAIN;
1521 }
1522
1523 static int control_pid_good(Service *s) {
1524 assert(s);
1525
1526 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1527 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1528 * means: we can't figure it out. */
1529
1530 return s->control_pid > 0;
1531 }
1532
1533 static int cgroup_good(Service *s) {
1534 int r;
1535
1536 assert(s);
1537
1538 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1539 * figure it out */
1540
1541 if (!UNIT(s)->cgroup_path)
1542 return 0;
1543
1544 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path);
1545 if (r < 0)
1546 return r;
1547
1548 return r == 0;
1549 }
1550
1551 static bool service_shall_restart(Service *s) {
1552 assert(s);
1553
1554 /* Don't restart after manual stops */
1555 if (s->forbid_restart)
1556 return false;
1557
1558 /* Never restart if this is configured as special exception */
1559 if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status))
1560 return false;
1561
1562 /* Restart if the exit code/status are configured as restart triggers */
1563 if (exit_status_set_test(&s->restart_force_status, s->main_exec_status.code, s->main_exec_status.status))
1564 return true;
1565
1566 switch (s->restart) {
1567
1568 case SERVICE_RESTART_NO:
1569 return false;
1570
1571 case SERVICE_RESTART_ALWAYS:
1572 return true;
1573
1574 case SERVICE_RESTART_ON_SUCCESS:
1575 return s->result == SERVICE_SUCCESS;
1576
1577 case SERVICE_RESTART_ON_FAILURE:
1578 return s->result != SERVICE_SUCCESS;
1579
1580 case SERVICE_RESTART_ON_ABNORMAL:
1581 return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE);
1582
1583 case SERVICE_RESTART_ON_WATCHDOG:
1584 return s->result == SERVICE_FAILURE_WATCHDOG;
1585
1586 case SERVICE_RESTART_ON_ABORT:
1587 return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
1588
1589 default:
1590 assert_not_reached("unknown restart setting");
1591 }
1592 }
1593
1594 static bool service_will_restart(Unit *u) {
1595 Service *s = SERVICE(u);
1596
1597 assert(s);
1598
1599 if (s->will_auto_restart)
1600 return true;
1601 if (s->state == SERVICE_AUTO_RESTART)
1602 return true;
1603 if (!UNIT(s)->job)
1604 return false;
1605 if (UNIT(s)->job->type == JOB_START)
1606 return true;
1607 return false;
1608 }
1609
1610 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1611 int r;
1612
1613 assert(s);
1614
1615 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1616 * undo what has already been enqueued. */
1617 if (unit_stop_pending(UNIT(s)))
1618 allow_restart = false;
1619
1620 if (s->result == SERVICE_SUCCESS)
1621 s->result = f;
1622
1623 if (s->result != SERVICE_SUCCESS)
1624 log_unit_warning(UNIT(s), "Failed with result '%s'.", service_result_to_string(s->result));
1625
1626 if (allow_restart && service_shall_restart(s))
1627 s->will_auto_restart = true;
1628
1629 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1630 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1631 s->n_keep_fd_store ++;
1632
1633 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1634
1635 if (s->will_auto_restart) {
1636 s->will_auto_restart = false;
1637
1638 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1639 if (r < 0) {
1640 s->n_keep_fd_store--;
1641 goto fail;
1642 }
1643
1644 service_set_state(s, SERVICE_AUTO_RESTART);
1645 } else
1646 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1647 * user can still introspect the counter. Do so on the next start. */
1648 s->flush_n_restarts = true;
1649
1650 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1651 * queue, so that the fd store is possibly gc'ed again */
1652 s->n_keep_fd_store--;
1653 unit_add_to_gc_queue(UNIT(s));
1654
1655 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1656 s->forbid_restart = false;
1657
1658 /* We want fresh tmpdirs in case service is started again immediately */
1659 s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
1660
1661 if (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_NO ||
1662 (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_RESTART && !service_will_restart(UNIT(s))))
1663 /* Also, remove the runtime directory */
1664 exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
1665
1666 /* Get rid of the IPC bits of the user */
1667 unit_unref_uid_gid(UNIT(s), true);
1668
1669 /* Release the user, and destroy it if we are the only remaining owner */
1670 dynamic_creds_destroy(&s->dynamic_creds);
1671
1672 /* Try to delete the pid file. At this point it will be
1673 * out-of-date, and some software might be confused by it, so
1674 * let's remove it. */
1675 if (s->pid_file)
1676 (void) unlink(s->pid_file);
1677
1678 return;
1679
1680 fail:
1681 log_unit_warning_errno(UNIT(s), r, "Failed to run install restart timer: %m");
1682 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1683 }
1684
1685 static void service_enter_stop_post(Service *s, ServiceResult f) {
1686 int r;
1687 assert(s);
1688
1689 if (s->result == SERVICE_SUCCESS)
1690 s->result = f;
1691
1692 service_unwatch_control_pid(s);
1693 unit_watch_all_pids(UNIT(s));
1694
1695 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1696 if (s->control_command) {
1697 s->control_command_id = SERVICE_EXEC_STOP_POST;
1698
1699 r = service_spawn(s,
1700 s->control_command,
1701 s->timeout_stop_usec,
1702 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1703 &s->control_pid);
1704 if (r < 0)
1705 goto fail;
1706
1707 service_set_state(s, SERVICE_STOP_POST);
1708 } else
1709 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1710
1711 return;
1712
1713 fail:
1714 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
1715 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1716 }
1717
1718 static int state_to_kill_operation(ServiceState state) {
1719 switch (state) {
1720
1721 case SERVICE_STOP_SIGABRT:
1722 return KILL_ABORT;
1723
1724 case SERVICE_STOP_SIGTERM:
1725 case SERVICE_FINAL_SIGTERM:
1726 return KILL_TERMINATE;
1727
1728 case SERVICE_STOP_SIGKILL:
1729 case SERVICE_FINAL_SIGKILL:
1730 return KILL_KILL;
1731
1732 default:
1733 return _KILL_OPERATION_INVALID;
1734 }
1735 }
1736
1737 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1738 int r;
1739
1740 assert(s);
1741
1742 if (s->result == SERVICE_SUCCESS)
1743 s->result = f;
1744
1745 unit_watch_all_pids(UNIT(s));
1746
1747 r = unit_kill_context(
1748 UNIT(s),
1749 &s->kill_context,
1750 state_to_kill_operation(state),
1751 s->main_pid,
1752 s->control_pid,
1753 s->main_pid_alien);
1754 if (r < 0)
1755 goto fail;
1756
1757 if (r > 0) {
1758 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1759 if (r < 0)
1760 goto fail;
1761
1762 service_set_state(s, state);
1763 } else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
1764 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1765 else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1766 service_enter_stop_post(s, SERVICE_SUCCESS);
1767 else if (state == SERVICE_FINAL_SIGTERM && s->kill_context.send_sigkill)
1768 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1769 else
1770 service_enter_dead(s, SERVICE_SUCCESS, true);
1771
1772 return;
1773
1774 fail:
1775 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
1776
1777 if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1778 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1779 else
1780 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1781 }
1782
1783 static void service_enter_stop_by_notify(Service *s) {
1784 assert(s);
1785
1786 unit_watch_all_pids(UNIT(s));
1787
1788 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1789
1790 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1791 service_set_state(s, SERVICE_STOP_SIGTERM);
1792 }
1793
1794 static void service_enter_stop(Service *s, ServiceResult f) {
1795 int r;
1796
1797 assert(s);
1798
1799 if (s->result == SERVICE_SUCCESS)
1800 s->result = f;
1801
1802 service_unwatch_control_pid(s);
1803 unit_watch_all_pids(UNIT(s));
1804
1805 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1806 if (s->control_command) {
1807 s->control_command_id = SERVICE_EXEC_STOP;
1808
1809 r = service_spawn(s,
1810 s->control_command,
1811 s->timeout_stop_usec,
1812 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1813 &s->control_pid);
1814 if (r < 0)
1815 goto fail;
1816
1817 service_set_state(s, SERVICE_STOP);
1818 } else
1819 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1820
1821 return;
1822
1823 fail:
1824 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop' task: %m");
1825 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1826 }
1827
1828 static bool service_good(Service *s) {
1829 int main_pid_ok;
1830 assert(s);
1831
1832 if (s->type == SERVICE_DBUS && !s->bus_name_good)
1833 return false;
1834
1835 main_pid_ok = main_pid_good(s);
1836 if (main_pid_ok > 0) /* It's alive */
1837 return true;
1838 if (main_pid_ok == 0) /* It's dead */
1839 return false;
1840
1841 /* OK, we don't know anything about the main PID, maybe
1842 * because there is none. Let's check the control group
1843 * instead. */
1844
1845 return cgroup_good(s) != 0;
1846 }
1847
1848 static void service_enter_running(Service *s, ServiceResult f) {
1849 assert(s);
1850
1851 if (s->result == SERVICE_SUCCESS)
1852 s->result = f;
1853
1854 service_unwatch_control_pid(s);
1855
1856 if (service_good(s)) {
1857
1858 /* If there are any queued up sd_notify()
1859 * notifications, process them now */
1860 if (s->notify_state == NOTIFY_RELOADING)
1861 service_enter_reload_by_notify(s);
1862 else if (s->notify_state == NOTIFY_STOPPING)
1863 service_enter_stop_by_notify(s);
1864 else {
1865 service_set_state(s, SERVICE_RUNNING);
1866 service_arm_timer(s, usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec));
1867 }
1868
1869 } else if (f != SERVICE_SUCCESS)
1870 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
1871 else if (s->remain_after_exit)
1872 service_set_state(s, SERVICE_EXITED);
1873 else
1874 service_enter_stop(s, SERVICE_SUCCESS);
1875 }
1876
1877 static void service_enter_start_post(Service *s) {
1878 int r;
1879 assert(s);
1880
1881 service_unwatch_control_pid(s);
1882 service_reset_watchdog(s);
1883
1884 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1885 if (s->control_command) {
1886 s->control_command_id = SERVICE_EXEC_START_POST;
1887
1888 r = service_spawn(s,
1889 s->control_command,
1890 s->timeout_start_usec,
1891 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
1892 &s->control_pid);
1893 if (r < 0)
1894 goto fail;
1895
1896 service_set_state(s, SERVICE_START_POST);
1897 } else
1898 service_enter_running(s, SERVICE_SUCCESS);
1899
1900 return;
1901
1902 fail:
1903 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
1904 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1905 }
1906
1907 static void service_kill_control_process(Service *s) {
1908 int r;
1909
1910 assert(s);
1911
1912 if (s->control_pid <= 0)
1913 return;
1914
1915 r = kill_and_sigcont(s->control_pid, SIGKILL);
1916 if (r < 0) {
1917 _cleanup_free_ char *comm = NULL;
1918
1919 (void) get_process_comm(s->control_pid, &comm);
1920
1921 log_unit_debug_errno(UNIT(s), r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m",
1922 s->control_pid, strna(comm));
1923 }
1924 }
1925
1926 static void service_enter_start(Service *s) {
1927 ExecCommand *c;
1928 usec_t timeout;
1929 pid_t pid;
1930 int r;
1931
1932 assert(s);
1933
1934 service_unwatch_control_pid(s);
1935 service_unwatch_main_pid(s);
1936
1937 unit_warn_leftover_processes(UNIT(s));
1938
1939 if (s->type == SERVICE_FORKING) {
1940 s->control_command_id = SERVICE_EXEC_START;
1941 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1942
1943 s->main_command = NULL;
1944 } else {
1945 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1946 s->control_command = NULL;
1947
1948 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1949 }
1950
1951 if (!c) {
1952 if (s->type != SERVICE_ONESHOT) {
1953 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1954 * happen if the configuration changes at runtime. In this case, let's enter a failure
1955 * state. */
1956 log_unit_error(UNIT(s), "There's no 'start' task anymore we could start: %m");
1957 r = -ENXIO;
1958 goto fail;
1959 }
1960
1961 service_enter_start_post(s);
1962 return;
1963 }
1964
1965 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
1966 /* For simple + idle this is the main process. We don't apply any timeout here, but
1967 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1968 timeout = USEC_INFINITY;
1969 else
1970 timeout = s->timeout_start_usec;
1971
1972 r = service_spawn(s,
1973 c,
1974 timeout,
1975 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
1976 &pid);
1977 if (r < 0)
1978 goto fail;
1979
1980 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE)) {
1981 /* For simple services we immediately start
1982 * the START_POST binaries. */
1983
1984 service_set_main_pid(s, pid);
1985 service_enter_start_post(s);
1986
1987 } else if (s->type == SERVICE_FORKING) {
1988
1989 /* For forking services we wait until the start
1990 * process exited. */
1991
1992 s->control_pid = pid;
1993 service_set_state(s, SERVICE_START);
1994
1995 } else if (IN_SET(s->type, SERVICE_ONESHOT, SERVICE_DBUS, SERVICE_NOTIFY)) {
1996
1997 /* For oneshot services we wait until the start
1998 * process exited, too, but it is our main process. */
1999
2000 /* For D-Bus services we know the main pid right away,
2001 * but wait for the bus name to appear on the
2002 * bus. Notify services are similar. */
2003
2004 service_set_main_pid(s, pid);
2005 service_set_state(s, SERVICE_START);
2006 } else
2007 assert_not_reached("Unknown service type");
2008
2009 return;
2010
2011 fail:
2012 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start' task: %m");
2013 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2014 }
2015
2016 static void service_enter_start_pre(Service *s) {
2017 int r;
2018
2019 assert(s);
2020
2021 service_unwatch_control_pid(s);
2022
2023 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2024 if (s->control_command) {
2025
2026 unit_warn_leftover_processes(UNIT(s));
2027
2028 s->control_command_id = SERVICE_EXEC_START_PRE;
2029
2030 r = service_spawn(s,
2031 s->control_command,
2032 s->timeout_start_usec,
2033 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_APPLY_TTY_STDIN,
2034 &s->control_pid);
2035 if (r < 0)
2036 goto fail;
2037
2038 service_set_state(s, SERVICE_START_PRE);
2039 } else
2040 service_enter_start(s);
2041
2042 return;
2043
2044 fail:
2045 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2046 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2047 }
2048
2049 static void service_enter_restart(Service *s) {
2050 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2051 int r;
2052
2053 assert(s);
2054
2055 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2056 /* Don't restart things if we are going down anyway */
2057 log_unit_info(UNIT(s), "Stop job pending for unit, delaying automatic restart.");
2058
2059 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
2060 if (r < 0)
2061 goto fail;
2062
2063 return;
2064 }
2065
2066 /* Any units that are bound to this service must also be
2067 * restarted. We use JOB_RESTART (instead of the more obvious
2068 * JOB_START) here so that those dependency jobs will be added
2069 * as well. */
2070 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, &error, NULL);
2071 if (r < 0)
2072 goto fail;
2073
2074 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2075 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2076 * explicitly however via the usual "systemctl reset-failure" logic. */
2077 s->n_restarts ++;
2078 s->flush_n_restarts = false;
2079
2080 log_struct(LOG_INFO,
2081 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR,
2082 LOG_UNIT_ID(UNIT(s)),
2083 LOG_UNIT_INVOCATION_ID(UNIT(s)),
2084 LOG_UNIT_MESSAGE(UNIT(s), "Scheduled restart job, restart counter is at %u.", s->n_restarts),
2085 "N_RESTARTS=%u", s->n_restarts,
2086 NULL);
2087
2088 /* Notify clients about changed restart counter */
2089 unit_add_to_dbus_queue(UNIT(s));
2090
2091 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2092 * it will be canceled as part of the service_stop() call that
2093 * is executed as part of JOB_RESTART. */
2094
2095 return;
2096
2097 fail:
2098 log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, -r));
2099 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2100 }
2101
2102 static void service_enter_reload_by_notify(Service *s) {
2103 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2104 int r;
2105
2106 assert(s);
2107
2108 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_start_usec));
2109 service_set_state(s, SERVICE_RELOAD);
2110
2111 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2112 r = manager_propagate_reload(UNIT(s)->manager, UNIT(s), JOB_FAIL, &error);
2113 if (r < 0)
2114 log_unit_warning(UNIT(s), "Failed to schedule propagation of reload: %s", bus_error_message(&error, -r));
2115 }
2116
2117 static void service_enter_reload(Service *s) {
2118 int r;
2119
2120 assert(s);
2121
2122 service_unwatch_control_pid(s);
2123 s->reload_result = SERVICE_SUCCESS;
2124
2125 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2126 if (s->control_command) {
2127 s->control_command_id = SERVICE_EXEC_RELOAD;
2128
2129 r = service_spawn(s,
2130 s->control_command,
2131 s->timeout_start_usec,
2132 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
2133 &s->control_pid);
2134 if (r < 0)
2135 goto fail;
2136
2137 service_set_state(s, SERVICE_RELOAD);
2138 } else
2139 service_enter_running(s, SERVICE_SUCCESS);
2140
2141 return;
2142
2143 fail:
2144 log_unit_warning_errno(UNIT(s), r, "Failed to run 'reload' task: %m");
2145 s->reload_result = SERVICE_FAILURE_RESOURCES;
2146 service_enter_running(s, SERVICE_SUCCESS);
2147 }
2148
2149 static void service_run_next_control(Service *s) {
2150 usec_t timeout;
2151 int r;
2152
2153 assert(s);
2154 assert(s->control_command);
2155 assert(s->control_command->command_next);
2156
2157 assert(s->control_command_id != SERVICE_EXEC_START);
2158
2159 s->control_command = s->control_command->command_next;
2160 service_unwatch_control_pid(s);
2161
2162 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
2163 timeout = s->timeout_start_usec;
2164 else
2165 timeout = s->timeout_stop_usec;
2166
2167 r = service_spawn(s,
2168 s->control_command,
2169 timeout,
2170 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|
2171 (IN_SET(s->control_command_id, SERVICE_EXEC_START_PRE, SERVICE_EXEC_STOP_POST) ? EXEC_APPLY_TTY_STDIN : 0)|
2172 (IN_SET(s->control_command_id, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST) ? EXEC_SETENV_RESULT : 0),
2173 &s->control_pid);
2174 if (r < 0)
2175 goto fail;
2176
2177 return;
2178
2179 fail:
2180 log_unit_warning_errno(UNIT(s), r, "Failed to run next control task: %m");
2181
2182 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START_POST, SERVICE_STOP))
2183 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2184 else if (s->state == SERVICE_STOP_POST)
2185 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2186 else if (s->state == SERVICE_RELOAD) {
2187 s->reload_result = SERVICE_FAILURE_RESOURCES;
2188 service_enter_running(s, SERVICE_SUCCESS);
2189 } else
2190 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2191 }
2192
2193 static void service_run_next_main(Service *s) {
2194 pid_t pid;
2195 int r;
2196
2197 assert(s);
2198 assert(s->main_command);
2199 assert(s->main_command->command_next);
2200 assert(s->type == SERVICE_ONESHOT);
2201
2202 s->main_command = s->main_command->command_next;
2203 service_unwatch_main_pid(s);
2204
2205 r = service_spawn(s,
2206 s->main_command,
2207 s->timeout_start_usec,
2208 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2209 &pid);
2210 if (r < 0)
2211 goto fail;
2212
2213 service_set_main_pid(s, pid);
2214
2215 return;
2216
2217 fail:
2218 log_unit_warning_errno(UNIT(s), r, "Failed to run next main task: %m");
2219 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2220 }
2221
2222 static int service_start(Unit *u) {
2223 Service *s = SERVICE(u);
2224 int r;
2225
2226 assert(s);
2227
2228 /* We cannot fulfill this request right now, try again later
2229 * please! */
2230 if (IN_SET(s->state,
2231 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2232 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2233 return -EAGAIN;
2234
2235 /* Already on it! */
2236 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST))
2237 return 0;
2238
2239 /* A service that will be restarted must be stopped first to
2240 * trigger BindsTo and/or OnFailure dependencies. If a user
2241 * does not want to wait for the holdoff time to elapse, the
2242 * service should be manually restarted, not started. We
2243 * simply return EAGAIN here, so that any start jobs stay
2244 * queued, and assume that the auto restart timer will
2245 * eventually trigger the restart. */
2246 if (s->state == SERVICE_AUTO_RESTART)
2247 return -EAGAIN;
2248
2249 assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED));
2250
2251 /* Make sure we don't enter a busy loop of some kind. */
2252 r = unit_start_limit_test(u);
2253 if (r < 0) {
2254 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT_HIT, false);
2255 return r;
2256 }
2257
2258 r = unit_acquire_invocation_id(u);
2259 if (r < 0)
2260 return r;
2261
2262 s->result = SERVICE_SUCCESS;
2263 s->reload_result = SERVICE_SUCCESS;
2264 s->main_pid_known = false;
2265 s->main_pid_alien = false;
2266 s->forbid_restart = false;
2267
2268 u->reset_accounting = true;
2269
2270 s->status_text = mfree(s->status_text);
2271 s->status_errno = 0;
2272
2273 s->notify_state = NOTIFY_UNKNOWN;
2274
2275 s->watchdog_override_enable = false;
2276 s->watchdog_override_usec = 0;
2277
2278 /* This is not an automatic restart? Flush the restart counter then */
2279 if (s->flush_n_restarts) {
2280 s->n_restarts = 0;
2281 s->flush_n_restarts = false;
2282 }
2283
2284 service_enter_start_pre(s);
2285 return 1;
2286 }
2287
2288 static int service_stop(Unit *u) {
2289 Service *s = SERVICE(u);
2290
2291 assert(s);
2292
2293 /* Don't create restart jobs from manual stops. */
2294 s->forbid_restart = true;
2295
2296 /* Already on it */
2297 if (IN_SET(s->state,
2298 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2299 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2300 return 0;
2301
2302 /* A restart will be scheduled or is in progress. */
2303 if (s->state == SERVICE_AUTO_RESTART) {
2304 service_set_state(s, SERVICE_DEAD);
2305 return 0;
2306 }
2307
2308 /* If there's already something running we go directly into
2309 * kill mode. */
2310 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD)) {
2311 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2312 return 0;
2313 }
2314
2315 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2316
2317 service_enter_stop(s, SERVICE_SUCCESS);
2318 return 1;
2319 }
2320
2321 static int service_reload(Unit *u) {
2322 Service *s = SERVICE(u);
2323
2324 assert(s);
2325
2326 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2327
2328 service_enter_reload(s);
2329 return 1;
2330 }
2331
2332 _pure_ static bool service_can_reload(Unit *u) {
2333 Service *s = SERVICE(u);
2334
2335 assert(s);
2336
2337 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2338 }
2339
2340 static unsigned service_exec_command_index(Unit *u, ServiceExecCommand id, ExecCommand *current) {
2341 Service *s = SERVICE(u);
2342 unsigned idx = 0;
2343 ExecCommand *first, *c;
2344
2345 assert(s);
2346
2347 first = s->exec_command[id];
2348
2349 /* Figure out where we are in the list by walking back to the beginning */
2350 for (c = current; c != first; c = c->command_prev)
2351 idx++;
2352
2353 return idx;
2354 }
2355
2356 static int service_serialize_exec_command(Unit *u, FILE *f, ExecCommand *command) {
2357 Service *s = SERVICE(u);
2358 ServiceExecCommand id;
2359 unsigned idx;
2360 const char *type;
2361 char **arg;
2362 _cleanup_free_ char *args = NULL, *p = NULL;
2363 size_t allocated = 0, length = 0;
2364
2365 assert(s);
2366 assert(f);
2367
2368 if (!command)
2369 return 0;
2370
2371 if (command == s->control_command) {
2372 type = "control";
2373 id = s->control_command_id;
2374 } else {
2375 type = "main";
2376 id = SERVICE_EXEC_START;
2377 }
2378
2379 idx = service_exec_command_index(u, id, command);
2380
2381 STRV_FOREACH(arg, command->argv) {
2382 size_t n;
2383 _cleanup_free_ char *e = NULL;
2384
2385 e = xescape(*arg, WHITESPACE);
2386 if (!e)
2387 return -ENOMEM;
2388
2389 n = strlen(e);
2390 if (!GREEDY_REALLOC(args, allocated, length + 1 + n + 1))
2391 return -ENOMEM;
2392
2393 if (length > 0)
2394 args[length++] = ' ';
2395
2396 memcpy(args + length, e, n);
2397 length += n;
2398 }
2399
2400 if (!GREEDY_REALLOC(args, allocated, length + 1))
2401 return -ENOMEM;
2402 args[length++] = 0;
2403
2404 p = xescape(command->path, WHITESPACE);
2405 if (!p)
2406 return -ENOMEM;
2407
2408 fprintf(f, "%s-command=%s %u %s %s\n", type, service_exec_command_to_string(id), idx, p, args);
2409
2410 return 0;
2411 }
2412
2413 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2414 Service *s = SERVICE(u);
2415 ServiceFDStore *fs;
2416 int r;
2417
2418 assert(u);
2419 assert(f);
2420 assert(fds);
2421
2422 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2423 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2424 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2425
2426 if (s->control_pid > 0)
2427 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
2428
2429 if (s->main_pid_known && s->main_pid > 0)
2430 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2431
2432 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2433 unit_serialize_item(u, f, "bus-name-good", yes_no(s->bus_name_good));
2434 unit_serialize_item(u, f, "bus-name-owner", s->bus_name_owner);
2435
2436 unit_serialize_item_format(u, f, "n-restarts", "%u", s->n_restarts);
2437 unit_serialize_item(u, f, "flush-n-restarts", yes_no(s->flush_n_restarts));
2438
2439 r = unit_serialize_item_escaped(u, f, "status-text", s->status_text);
2440 if (r < 0)
2441 return r;
2442
2443 service_serialize_exec_command(u, f, s->control_command);
2444 service_serialize_exec_command(u, f, s->main_command);
2445
2446 r = unit_serialize_item_fd(u, f, fds, "stdin-fd", s->stdin_fd);
2447 if (r < 0)
2448 return r;
2449 r = unit_serialize_item_fd(u, f, fds, "stdout-fd", s->stdout_fd);
2450 if (r < 0)
2451 return r;
2452 r = unit_serialize_item_fd(u, f, fds, "stderr-fd", s->stderr_fd);
2453 if (r < 0)
2454 return r;
2455
2456 if (UNIT_ISSET(s->accept_socket)) {
2457 r = unit_serialize_item(u, f, "accept-socket", UNIT_DEREF(s->accept_socket)->id);
2458 if (r < 0)
2459 return r;
2460 }
2461
2462 r = unit_serialize_item_fd(u, f, fds, "socket-fd", s->socket_fd);
2463 if (r < 0)
2464 return r;
2465
2466 LIST_FOREACH(fd_store, fs, s->fd_store) {
2467 _cleanup_free_ char *c = NULL;
2468 int copy;
2469
2470 copy = fdset_put_dup(fds, fs->fd);
2471 if (copy < 0)
2472 return copy;
2473
2474 c = cescape(fs->fdname);
2475
2476 unit_serialize_item_format(u, f, "fd-store-fd", "%i %s", copy, strempty(c));
2477 }
2478
2479 if (s->main_exec_status.pid > 0) {
2480 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
2481 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2482 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2483
2484 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2485 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2486 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2487 }
2488 }
2489
2490 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2491
2492 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2493
2494 if (s->watchdog_override_enable)
2495 unit_serialize_item_format(u, f, "watchdog-override-usec", USEC_FMT, s->watchdog_override_usec);
2496
2497 return 0;
2498 }
2499
2500 static int service_deserialize_exec_command(Unit *u, const char *key, const char *value) {
2501 Service *s = SERVICE(u);
2502 int r;
2503 unsigned idx = 0, i;
2504 bool control, found = false;
2505 ServiceExecCommand id = _SERVICE_EXEC_COMMAND_INVALID;
2506 ExecCommand *command = NULL;
2507 _cleanup_free_ char *path = NULL;
2508 _cleanup_strv_free_ char **argv = NULL;
2509
2510 enum ExecCommandState {
2511 STATE_EXEC_COMMAND_TYPE,
2512 STATE_EXEC_COMMAND_INDEX,
2513 STATE_EXEC_COMMAND_PATH,
2514 STATE_EXEC_COMMAND_ARGS,
2515 _STATE_EXEC_COMMAND_MAX,
2516 _STATE_EXEC_COMMAND_INVALID = -1,
2517 } state;
2518
2519 assert(s);
2520 assert(key);
2521 assert(value);
2522
2523 control = streq(key, "control-command");
2524
2525 state = STATE_EXEC_COMMAND_TYPE;
2526
2527 for (;;) {
2528 _cleanup_free_ char *arg = NULL;
2529
2530 r = extract_first_word(&value, &arg, NULL, EXTRACT_CUNESCAPE);
2531 if (r == 0)
2532 break;
2533 else if (r < 0)
2534 return r;
2535
2536 switch (state) {
2537 case STATE_EXEC_COMMAND_TYPE:
2538 id = service_exec_command_from_string(arg);
2539 if (id < 0)
2540 return -EINVAL;
2541
2542 state = STATE_EXEC_COMMAND_INDEX;
2543 break;
2544 case STATE_EXEC_COMMAND_INDEX:
2545 r = safe_atou(arg, &idx);
2546 if (r < 0)
2547 return -EINVAL;
2548
2549 state = STATE_EXEC_COMMAND_PATH;
2550 break;
2551 case STATE_EXEC_COMMAND_PATH:
2552 path = TAKE_PTR(arg);
2553 state = STATE_EXEC_COMMAND_ARGS;
2554
2555 if (!path_is_absolute(path))
2556 return -EINVAL;
2557 break;
2558 case STATE_EXEC_COMMAND_ARGS:
2559 r = strv_extend(&argv, arg);
2560 if (r < 0)
2561 return -ENOMEM;
2562 break;
2563 default:
2564 assert_not_reached("Unknown error at deserialization of exec command");
2565 break;
2566 }
2567 }
2568
2569 if (state != STATE_EXEC_COMMAND_ARGS)
2570 return -EINVAL;
2571
2572 /* Let's check whether exec command on given offset matches data that we just deserialized */
2573 for (command = s->exec_command[id], i = 0; command; command = command->command_next, i++) {
2574 if (i != idx)
2575 continue;
2576
2577 found = strv_equal(argv, command->argv) && streq(command->path, path);
2578 break;
2579 }
2580
2581 if (!found) {
2582 /* Command at the index we serialized is different, let's look for command that exactly
2583 * matches but is on different index. If there is no such command we will not resume execution. */
2584 for (command = s->exec_command[id]; command; command = command->command_next)
2585 if (strv_equal(command->argv, argv) && streq(command->path, path))
2586 break;
2587 }
2588
2589 if (command && control)
2590 s->control_command = command;
2591 else if (command)
2592 s->main_command = command;
2593 else
2594 log_unit_warning(u, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2595
2596 return 0;
2597 }
2598
2599 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2600 Service *s = SERVICE(u);
2601 int r;
2602
2603 assert(u);
2604 assert(key);
2605 assert(value);
2606 assert(fds);
2607
2608 if (streq(key, "state")) {
2609 ServiceState state;
2610
2611 state = service_state_from_string(value);
2612 if (state < 0)
2613 log_unit_debug(u, "Failed to parse state value: %s", value);
2614 else
2615 s->deserialized_state = state;
2616 } else if (streq(key, "result")) {
2617 ServiceResult f;
2618
2619 f = service_result_from_string(value);
2620 if (f < 0)
2621 log_unit_debug(u, "Failed to parse result value: %s", value);
2622 else if (f != SERVICE_SUCCESS)
2623 s->result = f;
2624
2625 } else if (streq(key, "reload-result")) {
2626 ServiceResult f;
2627
2628 f = service_result_from_string(value);
2629 if (f < 0)
2630 log_unit_debug(u, "Failed to parse reload result value: %s", value);
2631 else if (f != SERVICE_SUCCESS)
2632 s->reload_result = f;
2633
2634 } else if (streq(key, "control-pid")) {
2635 pid_t pid;
2636
2637 if (parse_pid(value, &pid) < 0)
2638 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2639 else
2640 s->control_pid = pid;
2641 } else if (streq(key, "main-pid")) {
2642 pid_t pid;
2643
2644 if (parse_pid(value, &pid) < 0)
2645 log_unit_debug(u, "Failed to parse main-pid value: %s", value);
2646 else
2647 (void) service_set_main_pid(s, pid);
2648 } else if (streq(key, "main-pid-known")) {
2649 int b;
2650
2651 b = parse_boolean(value);
2652 if (b < 0)
2653 log_unit_debug(u, "Failed to parse main-pid-known value: %s", value);
2654 else
2655 s->main_pid_known = b;
2656 } else if (streq(key, "bus-name-good")) {
2657 int b;
2658
2659 b = parse_boolean(value);
2660 if (b < 0)
2661 log_unit_debug(u, "Failed to parse bus-name-good value: %s", value);
2662 else
2663 s->bus_name_good = b;
2664 } else if (streq(key, "bus-name-owner")) {
2665 r = free_and_strdup(&s->bus_name_owner, value);
2666 if (r < 0)
2667 log_unit_error_errno(u, r, "Unable to deserialize current bus owner %s: %m", value);
2668 } else if (streq(key, "status-text")) {
2669 char *t;
2670
2671 r = cunescape(value, 0, &t);
2672 if (r < 0)
2673 log_unit_debug_errno(u, r, "Failed to unescape status text: %s", value);
2674 else {
2675 free(s->status_text);
2676 s->status_text = t;
2677 }
2678
2679 } else if (streq(key, "accept-socket")) {
2680 Unit *socket;
2681
2682 r = manager_load_unit(u->manager, value, NULL, NULL, &socket);
2683 if (r < 0)
2684 log_unit_debug_errno(u, r, "Failed to load accept-socket unit: %s", value);
2685 else {
2686 unit_ref_set(&s->accept_socket, u, socket);
2687 SOCKET(socket)->n_connections++;
2688 }
2689
2690 } else if (streq(key, "socket-fd")) {
2691 int fd;
2692
2693 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2694 log_unit_debug(u, "Failed to parse socket-fd value: %s", value);
2695 else {
2696 asynchronous_close(s->socket_fd);
2697 s->socket_fd = fdset_remove(fds, fd);
2698 }
2699 } else if (streq(key, "fd-store-fd")) {
2700 const char *fdv;
2701 size_t pf;
2702 int fd;
2703
2704 pf = strcspn(value, WHITESPACE);
2705 fdv = strndupa(value, pf);
2706
2707 if (safe_atoi(fdv, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2708 log_unit_debug(u, "Failed to parse fd-store-fd value: %s", value);
2709 else {
2710 _cleanup_free_ char *t = NULL;
2711 const char *fdn;
2712
2713 fdn = value + pf;
2714 fdn += strspn(fdn, WHITESPACE);
2715 (void) cunescape(fdn, 0, &t);
2716
2717 r = service_add_fd_store(s, fd, t);
2718 if (r < 0)
2719 log_unit_error_errno(u, r, "Failed to add fd to store: %m");
2720 else
2721 fdset_remove(fds, fd);
2722 }
2723
2724 } else if (streq(key, "main-exec-status-pid")) {
2725 pid_t pid;
2726
2727 if (parse_pid(value, &pid) < 0)
2728 log_unit_debug(u, "Failed to parse main-exec-status-pid value: %s", value);
2729 else
2730 s->main_exec_status.pid = pid;
2731 } else if (streq(key, "main-exec-status-code")) {
2732 int i;
2733
2734 if (safe_atoi(value, &i) < 0)
2735 log_unit_debug(u, "Failed to parse main-exec-status-code value: %s", value);
2736 else
2737 s->main_exec_status.code = i;
2738 } else if (streq(key, "main-exec-status-status")) {
2739 int i;
2740
2741 if (safe_atoi(value, &i) < 0)
2742 log_unit_debug(u, "Failed to parse main-exec-status-status value: %s", value);
2743 else
2744 s->main_exec_status.status = i;
2745 } else if (streq(key, "main-exec-status-start"))
2746 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2747 else if (streq(key, "main-exec-status-exit"))
2748 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2749 else if (streq(key, "watchdog-timestamp"))
2750 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2751 else if (streq(key, "forbid-restart")) {
2752 int b;
2753
2754 b = parse_boolean(value);
2755 if (b < 0)
2756 log_unit_debug(u, "Failed to parse forbid-restart value: %s", value);
2757 else
2758 s->forbid_restart = b;
2759 } else if (streq(key, "stdin-fd")) {
2760 int fd;
2761
2762 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2763 log_unit_debug(u, "Failed to parse stdin-fd value: %s", value);
2764 else {
2765 asynchronous_close(s->stdin_fd);
2766 s->stdin_fd = fdset_remove(fds, fd);
2767 s->exec_context.stdio_as_fds = true;
2768 }
2769 } else if (streq(key, "stdout-fd")) {
2770 int fd;
2771
2772 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2773 log_unit_debug(u, "Failed to parse stdout-fd value: %s", value);
2774 else {
2775 asynchronous_close(s->stdout_fd);
2776 s->stdout_fd = fdset_remove(fds, fd);
2777 s->exec_context.stdio_as_fds = true;
2778 }
2779 } else if (streq(key, "stderr-fd")) {
2780 int fd;
2781
2782 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2783 log_unit_debug(u, "Failed to parse stderr-fd value: %s", value);
2784 else {
2785 asynchronous_close(s->stderr_fd);
2786 s->stderr_fd = fdset_remove(fds, fd);
2787 s->exec_context.stdio_as_fds = true;
2788 }
2789 } else if (streq(key, "watchdog-override-usec")) {
2790 usec_t watchdog_override_usec;
2791 if (timestamp_deserialize(value, &watchdog_override_usec) < 0)
2792 log_unit_debug(u, "Failed to parse watchdog_override_usec value: %s", value);
2793 else {
2794 s->watchdog_override_enable = true;
2795 s->watchdog_override_usec = watchdog_override_usec;
2796 }
2797 } else if (STR_IN_SET(key, "main-command", "control-command")) {
2798 r = service_deserialize_exec_command(u, key, value);
2799 if (r < 0)
2800 log_unit_debug_errno(u, r, "Failed to parse serialized command \"%s\": %m", value);
2801
2802 } else if (streq(key, "n-restarts")) {
2803 r = safe_atou(value, &s->n_restarts);
2804 if (r < 0)
2805 log_unit_debug_errno(u, r, "Failed to parse serialized restart counter '%s': %m", value);
2806
2807 } else if (streq(key, "flush-n-restarts")) {
2808 r = parse_boolean(value);
2809 if (r < 0)
2810 log_unit_debug_errno(u, r, "Failed to parse serialized flush restart counter setting '%s': %m", value);
2811 else
2812 s->flush_n_restarts = r;
2813 } else
2814 log_unit_debug(u, "Unknown serialization key: %s", key);
2815
2816 return 0;
2817 }
2818
2819 _pure_ static UnitActiveState service_active_state(Unit *u) {
2820 const UnitActiveState *table;
2821
2822 assert(u);
2823
2824 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2825
2826 return table[SERVICE(u)->state];
2827 }
2828
2829 static const char *service_sub_state_to_string(Unit *u) {
2830 assert(u);
2831
2832 return service_state_to_string(SERVICE(u)->state);
2833 }
2834
2835 static bool service_may_gc(Unit *u) {
2836 Service *s = SERVICE(u);
2837
2838 assert(s);
2839
2840 /* Never clean up services that still have a process around, even if the service is formally dead. Note that
2841 * unit_may_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
2842 * have moved outside of the cgroup. */
2843
2844 if (main_pid_good(s) > 0 ||
2845 control_pid_good(s) > 0)
2846 return false;
2847
2848 return true;
2849 }
2850
2851 static int service_retry_pid_file(Service *s) {
2852 int r;
2853
2854 assert(s->pid_file);
2855 assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
2856
2857 r = service_load_pid_file(s, false);
2858 if (r < 0)
2859 return r;
2860
2861 service_unwatch_pid_file(s);
2862
2863 service_enter_running(s, SERVICE_SUCCESS);
2864 return 0;
2865 }
2866
2867 static int service_watch_pid_file(Service *s) {
2868 int r;
2869
2870 log_unit_debug(UNIT(s), "Setting watch for PID file %s", s->pid_file_pathspec->path);
2871
2872 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2873 if (r < 0)
2874 goto fail;
2875
2876 /* the pidfile might have appeared just before we set the watch */
2877 log_unit_debug(UNIT(s), "Trying to read PID file %s in case it changed", s->pid_file_pathspec->path);
2878 service_retry_pid_file(s);
2879
2880 return 0;
2881 fail:
2882 log_unit_error_errno(UNIT(s), r, "Failed to set a watch for PID file %s: %m", s->pid_file_pathspec->path);
2883 service_unwatch_pid_file(s);
2884 return r;
2885 }
2886
2887 static int service_demand_pid_file(Service *s) {
2888 PathSpec *ps;
2889
2890 assert(s->pid_file);
2891 assert(!s->pid_file_pathspec);
2892
2893 ps = new0(PathSpec, 1);
2894 if (!ps)
2895 return -ENOMEM;
2896
2897 ps->unit = UNIT(s);
2898 ps->path = strdup(s->pid_file);
2899 if (!ps->path) {
2900 free(ps);
2901 return -ENOMEM;
2902 }
2903
2904 path_kill_slashes(ps->path);
2905
2906 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2907 * keep their PID file open all the time. */
2908 ps->type = PATH_MODIFIED;
2909 ps->inotify_fd = -1;
2910
2911 s->pid_file_pathspec = ps;
2912
2913 return service_watch_pid_file(s);
2914 }
2915
2916 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2917 PathSpec *p = userdata;
2918 Service *s;
2919
2920 assert(p);
2921
2922 s = SERVICE(p->unit);
2923
2924 assert(s);
2925 assert(fd >= 0);
2926 assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
2927 assert(s->pid_file_pathspec);
2928 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2929
2930 log_unit_debug(UNIT(s), "inotify event");
2931
2932 if (path_spec_fd_event(p, events) < 0)
2933 goto fail;
2934
2935 if (service_retry_pid_file(s) == 0)
2936 return 0;
2937
2938 if (service_watch_pid_file(s) < 0)
2939 goto fail;
2940
2941 return 0;
2942
2943 fail:
2944 service_unwatch_pid_file(s);
2945 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2946 return 0;
2947 }
2948
2949 static void service_notify_cgroup_empty_event(Unit *u) {
2950 Service *s = SERVICE(u);
2951
2952 assert(u);
2953
2954 log_unit_debug(u, "cgroup is empty");
2955
2956 switch (s->state) {
2957
2958 /* Waiting for SIGCHLD is usually more interesting,
2959 * because it includes return codes/signals. Which is
2960 * why we ignore the cgroup events for most cases,
2961 * except when we don't know pid which to expect the
2962 * SIGCHLD for. */
2963
2964 case SERVICE_START:
2965 if (s->type == SERVICE_NOTIFY &&
2966 main_pid_good(s) == 0 &&
2967 control_pid_good(s) == 0) {
2968 /* No chance of getting a ready notification anymore */
2969 service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
2970 break;
2971 }
2972
2973 _fallthrough_;
2974 case SERVICE_START_POST:
2975 if (s->pid_file_pathspec &&
2976 main_pid_good(s) == 0 &&
2977 control_pid_good(s) == 0) {
2978
2979 /* Give up hoping for the daemon to write its PID file */
2980 log_unit_warning(u, "Daemon never wrote its PID file. Failing.");
2981
2982 service_unwatch_pid_file(s);
2983 if (s->state == SERVICE_START)
2984 service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
2985 else
2986 service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
2987 }
2988 break;
2989
2990 case SERVICE_RUNNING:
2991 /* service_enter_running() will figure out what to do */
2992 service_enter_running(s, SERVICE_SUCCESS);
2993 break;
2994
2995 case SERVICE_STOP_SIGABRT:
2996 case SERVICE_STOP_SIGTERM:
2997 case SERVICE_STOP_SIGKILL:
2998
2999 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3000 service_enter_stop_post(s, SERVICE_SUCCESS);
3001
3002 break;
3003
3004 case SERVICE_STOP_POST:
3005 case SERVICE_FINAL_SIGTERM:
3006 case SERVICE_FINAL_SIGKILL:
3007 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3008 service_enter_dead(s, SERVICE_SUCCESS, true);
3009
3010 break;
3011
3012 default:
3013 ;
3014 }
3015 }
3016
3017 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
3018 bool notify_dbus = true;
3019 Service *s = SERVICE(u);
3020 ServiceResult f;
3021
3022 assert(s);
3023 assert(pid >= 0);
3024
3025 if (is_clean_exit(code, status, s->type == SERVICE_ONESHOT ? EXIT_CLEAN_COMMAND : EXIT_CLEAN_DAEMON, &s->success_status))
3026 f = SERVICE_SUCCESS;
3027 else if (code == CLD_EXITED)
3028 f = SERVICE_FAILURE_EXIT_CODE;
3029 else if (code == CLD_KILLED)
3030 f = SERVICE_FAILURE_SIGNAL;
3031 else if (code == CLD_DUMPED)
3032 f = SERVICE_FAILURE_CORE_DUMP;
3033 else
3034 assert_not_reached("Unknown code");
3035
3036 if (s->main_pid == pid) {
3037 /* Forking services may occasionally move to a new PID.
3038 * As long as they update the PID file before exiting the old
3039 * PID, they're fine. */
3040 if (service_load_pid_file(s, false) > 0)
3041 return;
3042
3043 s->main_pid = 0;
3044 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
3045
3046 if (s->main_command) {
3047 /* If this is not a forking service than the
3048 * main process got started and hence we copy
3049 * the exit status so that it is recorded both
3050 * as main and as control process exit
3051 * status */
3052
3053 s->main_command->exec_status = s->main_exec_status;
3054
3055 if (s->main_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3056 f = SERVICE_SUCCESS;
3057 } else if (s->exec_command[SERVICE_EXEC_START]) {
3058
3059 /* If this is a forked process, then we should
3060 * ignore the return value if this was
3061 * configured for the starter process */
3062
3063 if (s->exec_command[SERVICE_EXEC_START]->flags & EXEC_COMMAND_IGNORE_FAILURE)
3064 f = SERVICE_SUCCESS;
3065 }
3066
3067 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
3068 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
3069 * that the service already logged the reason at a higher log level on its own. However, if the service
3070 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
3071 * our log level to WARNING then. */
3072
3073 log_struct(f == SERVICE_SUCCESS ? LOG_DEBUG :
3074 (code == CLD_EXITED ? LOG_NOTICE : LOG_WARNING),
3075 LOG_UNIT_MESSAGE(u, "Main process exited, code=%s, status=%i/%s",
3076 sigchld_code_to_string(code), status,
3077 strna(code == CLD_EXITED
3078 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3079 : signal_to_string(status))),
3080 "EXIT_CODE=%s", sigchld_code_to_string(code),
3081 "EXIT_STATUS=%i", status,
3082 LOG_UNIT_ID(u),
3083 LOG_UNIT_INVOCATION_ID(u),
3084 NULL);
3085
3086 if (s->result == SERVICE_SUCCESS)
3087 s->result = f;
3088
3089 if (s->main_command &&
3090 s->main_command->command_next &&
3091 s->type == SERVICE_ONESHOT &&
3092 f == SERVICE_SUCCESS) {
3093
3094 /* There is another command to *
3095 * execute, so let's do that. */
3096
3097 log_unit_debug(u, "Running next main command for state %s.", service_state_to_string(s->state));
3098 service_run_next_main(s);
3099
3100 } else {
3101
3102 /* The service exited, so the service is officially
3103 * gone. */
3104 s->main_command = NULL;
3105
3106 switch (s->state) {
3107
3108 case SERVICE_START_POST:
3109 case SERVICE_RELOAD:
3110 case SERVICE_STOP:
3111 /* Need to wait until the operation is
3112 * done */
3113 break;
3114
3115 case SERVICE_START:
3116 if (s->type == SERVICE_ONESHOT) {
3117 /* This was our main goal, so let's go on */
3118 if (f == SERVICE_SUCCESS)
3119 service_enter_start_post(s);
3120 else
3121 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3122 break;
3123 } else if (s->type == SERVICE_NOTIFY) {
3124 /* Only enter running through a notification, so that the
3125 * SERVICE_START state signifies that no ready notification
3126 * has been received */
3127 if (f != SERVICE_SUCCESS)
3128 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3129 else if (!s->remain_after_exit || s->notify_access == NOTIFY_MAIN)
3130 /* The service has never been and will never be active */
3131 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3132 break;
3133 }
3134
3135 _fallthrough_;
3136 case SERVICE_RUNNING:
3137 service_enter_running(s, f);
3138 break;
3139
3140 case SERVICE_STOP_SIGABRT:
3141 case SERVICE_STOP_SIGTERM:
3142 case SERVICE_STOP_SIGKILL:
3143
3144 if (control_pid_good(s) <= 0)
3145 service_enter_stop_post(s, f);
3146
3147 /* If there is still a control process, wait for that first */
3148 break;
3149
3150 case SERVICE_STOP_POST:
3151 case SERVICE_FINAL_SIGTERM:
3152 case SERVICE_FINAL_SIGKILL:
3153
3154 if (control_pid_good(s) <= 0)
3155 service_enter_dead(s, f, true);
3156 break;
3157
3158 default:
3159 assert_not_reached("Uh, main process died at wrong time.");
3160 }
3161 }
3162
3163 } else if (s->control_pid == pid) {
3164 s->control_pid = 0;
3165
3166 if (s->control_command) {
3167 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
3168
3169 if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3170 f = SERVICE_SUCCESS;
3171 }
3172
3173 log_unit_full(u, f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
3174 "Control process exited, code=%s status=%i",
3175 sigchld_code_to_string(code), status);
3176
3177 if (s->result == SERVICE_SUCCESS)
3178 s->result = f;
3179
3180 if (s->control_command &&
3181 s->control_command->command_next &&
3182 f == SERVICE_SUCCESS) {
3183
3184 /* There is another command to *
3185 * execute, so let's do that. */
3186
3187 log_unit_debug(u, "Running next control command for state %s.", service_state_to_string(s->state));
3188 service_run_next_control(s);
3189
3190 } else {
3191 /* No further commands for this step, so let's
3192 * figure out what to do next */
3193
3194 s->control_command = NULL;
3195 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3196
3197 log_unit_debug(u, "Got final SIGCHLD for state %s.", service_state_to_string(s->state));
3198
3199 switch (s->state) {
3200
3201 case SERVICE_START_PRE:
3202 if (f == SERVICE_SUCCESS)
3203 service_enter_start(s);
3204 else
3205 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3206 break;
3207
3208 case SERVICE_START:
3209 if (s->type != SERVICE_FORKING)
3210 /* Maybe spurious event due to a reload that changed the type? */
3211 break;
3212
3213 if (f != SERVICE_SUCCESS) {
3214 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3215 break;
3216 }
3217
3218 if (s->pid_file) {
3219 bool has_start_post;
3220 int r;
3221
3222 /* Let's try to load the pid file here if we can.
3223 * The PID file might actually be created by a START_POST
3224 * script. In that case don't worry if the loading fails. */
3225
3226 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3227 r = service_load_pid_file(s, !has_start_post);
3228 if (!has_start_post && r < 0) {
3229 r = service_demand_pid_file(s);
3230 if (r < 0 || cgroup_good(s) == 0)
3231 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3232 break;
3233 }
3234 } else
3235 service_search_main_pid(s);
3236
3237 service_enter_start_post(s);
3238 break;
3239
3240 case SERVICE_START_POST:
3241 if (f != SERVICE_SUCCESS) {
3242 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3243 break;
3244 }
3245
3246 if (s->pid_file) {
3247 int r;
3248
3249 r = service_load_pid_file(s, true);
3250 if (r < 0) {
3251 r = service_demand_pid_file(s);
3252 if (r < 0 || cgroup_good(s) == 0)
3253 service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
3254 break;
3255 }
3256 } else
3257 service_search_main_pid(s);
3258
3259 service_enter_running(s, SERVICE_SUCCESS);
3260 break;
3261
3262 case SERVICE_RELOAD:
3263 if (f == SERVICE_SUCCESS)
3264 if (service_load_pid_file(s, true) < 0)
3265 service_search_main_pid(s);
3266
3267 s->reload_result = f;
3268 service_enter_running(s, SERVICE_SUCCESS);
3269 break;
3270
3271 case SERVICE_STOP:
3272 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3273 break;
3274
3275 case SERVICE_STOP_SIGABRT:
3276 case SERVICE_STOP_SIGTERM:
3277 case SERVICE_STOP_SIGKILL:
3278 if (main_pid_good(s) <= 0)
3279 service_enter_stop_post(s, f);
3280
3281 /* If there is still a service
3282 * process around, wait until
3283 * that one quit, too */
3284 break;
3285
3286 case SERVICE_STOP_POST:
3287 case SERVICE_FINAL_SIGTERM:
3288 case SERVICE_FINAL_SIGKILL:
3289 if (main_pid_good(s) <= 0)
3290 service_enter_dead(s, f, true);
3291 break;
3292
3293 default:
3294 assert_not_reached("Uh, control process died at wrong time.");
3295 }
3296 }
3297 } else /* Neither control nor main PID? If so, don't notify about anything */
3298 notify_dbus = false;
3299
3300 /* Notify clients about changed exit status */
3301 if (notify_dbus)
3302 unit_add_to_dbus_queue(u);
3303
3304 /* If we get a SIGCHLD event for one of the processes we were interested in, then we look for others to watch,
3305 * under the assumption that we'll sooner or later get a SIGCHLD for them, as the original process we watched
3306 * was probably the parent of them, and they are hence now our children. */
3307 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
3308 unit_watch_all_pids(u);
3309
3310 /* If the PID set is empty now, then let's check if the cgroup is empty too and finish off the unit. */
3311 unit_synthesize_cgroup_empty_event(u);
3312 }
3313
3314 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3315 Service *s = SERVICE(userdata);
3316
3317 assert(s);
3318 assert(source == s->timer_event_source);
3319
3320 switch (s->state) {
3321
3322 case SERVICE_START_PRE:
3323 case SERVICE_START:
3324 log_unit_warning(UNIT(s), "%s operation timed out. Terminating.", s->state == SERVICE_START ? "Start" : "Start-pre");
3325 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3326 break;
3327
3328 case SERVICE_START_POST:
3329 log_unit_warning(UNIT(s), "Start-post operation timed out. Stopping.");
3330 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3331 break;
3332
3333 case SERVICE_RUNNING:
3334 log_unit_warning(UNIT(s), "Service reached runtime time limit. Stopping.");
3335 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3336 break;
3337
3338 case SERVICE_RELOAD:
3339 log_unit_warning(UNIT(s), "Reload operation timed out. Killing reload process.");
3340 service_kill_control_process(s);
3341 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3342 service_enter_running(s, SERVICE_SUCCESS);
3343 break;
3344
3345 case SERVICE_STOP:
3346 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
3347 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3348 break;
3349
3350 case SERVICE_STOP_SIGABRT:
3351 log_unit_warning(UNIT(s), "State 'stop-sigabrt' timed out. Terminating.");
3352 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3353 break;
3354
3355 case SERVICE_STOP_SIGTERM:
3356 if (s->kill_context.send_sigkill) {
3357 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Killing.");
3358 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3359 } else {
3360 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3361 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3362 }
3363
3364 break;
3365
3366 case SERVICE_STOP_SIGKILL:
3367 /* Uh, we sent a SIGKILL and it is still not gone?
3368 * Must be something we cannot kill, so let's just be
3369 * weirded out and continue */
3370
3371 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
3372 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3373 break;
3374
3375 case SERVICE_STOP_POST:
3376 log_unit_warning(UNIT(s), "State 'stop-post' timed out. Terminating.");
3377 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3378 break;
3379
3380 case SERVICE_FINAL_SIGTERM:
3381 if (s->kill_context.send_sigkill) {
3382 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Killing.");
3383 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3384 } else {
3385 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3386 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3387 }
3388
3389 break;
3390
3391 case SERVICE_FINAL_SIGKILL:
3392 log_unit_warning(UNIT(s), "Processes still around after final SIGKILL. Entering failed mode.");
3393 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3394 break;
3395
3396 case SERVICE_AUTO_RESTART:
3397 if (s->restart_usec > 0) {
3398 char buf_restart[FORMAT_TIMESPAN_MAX];
3399 log_unit_info(UNIT(s),
3400 "Service RestartSec=%s expired, scheduling restart.",
3401 format_timespan(buf_restart, sizeof buf_restart, s->restart_usec, USEC_PER_SEC));
3402 } else
3403 log_unit_info(UNIT(s),
3404 "Service has no hold-off time (RestartSec=0), scheduling restart.");
3405
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.