]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/service.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
core: fold manager_set_exec_params() into unit_set_exec_params()
[thirdparty/systemd.git] / src / core / service.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2010 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <errno.h>
22 #include <signal.h>
23 #include <unistd.h>
24
25 #include "sd-messages.h"
26
27 #include "alloc-util.h"
28 #include "async.h"
29 #include "bus-error.h"
30 #include "bus-kernel.h"
31 #include "bus-util.h"
32 #include "dbus-service.h"
33 #include "def.h"
34 #include "env-util.h"
35 #include "escape.h"
36 #include "exit-status.h"
37 #include "fd-util.h"
38 #include "fileio.h"
39 #include "format-util.h"
40 #include "fs-util.h"
41 #include "load-dropin.h"
42 #include "load-fragment.h"
43 #include "log.h"
44 #include "manager.h"
45 #include "parse-util.h"
46 #include "path-util.h"
47 #include "process-util.h"
48 #include "service.h"
49 #include "signal-util.h"
50 #include "special.h"
51 #include "stdio-util.h"
52 #include "string-table.h"
53 #include "string-util.h"
54 #include "strv.h"
55 #include "unit-name.h"
56 #include "unit.h"
57 #include "utf8.h"
58 #include "util.h"
59
60 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
61 [SERVICE_DEAD] = UNIT_INACTIVE,
62 [SERVICE_START_PRE] = UNIT_ACTIVATING,
63 [SERVICE_START] = UNIT_ACTIVATING,
64 [SERVICE_START_POST] = UNIT_ACTIVATING,
65 [SERVICE_RUNNING] = UNIT_ACTIVE,
66 [SERVICE_EXITED] = UNIT_ACTIVE,
67 [SERVICE_RELOAD] = UNIT_RELOADING,
68 [SERVICE_STOP] = UNIT_DEACTIVATING,
69 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
70 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
71 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
72 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
73 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
74 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
75 [SERVICE_FAILED] = UNIT_FAILED,
76 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
77 };
78
79 /* For Type=idle we never want to delay any other jobs, hence we
80 * consider idle jobs active as soon as we start working on them */
81 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
82 [SERVICE_DEAD] = UNIT_INACTIVE,
83 [SERVICE_START_PRE] = UNIT_ACTIVE,
84 [SERVICE_START] = UNIT_ACTIVE,
85 [SERVICE_START_POST] = UNIT_ACTIVE,
86 [SERVICE_RUNNING] = UNIT_ACTIVE,
87 [SERVICE_EXITED] = UNIT_ACTIVE,
88 [SERVICE_RELOAD] = UNIT_RELOADING,
89 [SERVICE_STOP] = UNIT_DEACTIVATING,
90 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
91 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
92 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
93 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
94 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
95 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
96 [SERVICE_FAILED] = UNIT_FAILED,
97 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
98 };
99
100 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
101 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
102 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
103
104 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
105 static void service_enter_reload_by_notify(Service *s);
106
107 static void service_init(Unit *u) {
108 Service *s = SERVICE(u);
109
110 assert(u);
111 assert(u->load_state == UNIT_STUB);
112
113 s->timeout_start_usec = u->manager->default_timeout_start_usec;
114 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
115 s->restart_usec = u->manager->default_restart_usec;
116 s->runtime_max_usec = USEC_INFINITY;
117 s->type = _SERVICE_TYPE_INVALID;
118 s->socket_fd = -1;
119 s->stdin_fd = s->stdout_fd = s->stderr_fd = -1;
120 s->guess_main_pid = true;
121
122 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
123 }
124
125 static void service_unwatch_control_pid(Service *s) {
126 assert(s);
127
128 if (s->control_pid <= 0)
129 return;
130
131 unit_unwatch_pid(UNIT(s), s->control_pid);
132 s->control_pid = 0;
133 }
134
135 static void service_unwatch_main_pid(Service *s) {
136 assert(s);
137
138 if (s->main_pid <= 0)
139 return;
140
141 unit_unwatch_pid(UNIT(s), s->main_pid);
142 s->main_pid = 0;
143 }
144
145 static void service_unwatch_pid_file(Service *s) {
146 if (!s->pid_file_pathspec)
147 return;
148
149 log_unit_debug(UNIT(s), "Stopping watch for PID file %s", s->pid_file_pathspec->path);
150 path_spec_unwatch(s->pid_file_pathspec);
151 path_spec_done(s->pid_file_pathspec);
152 s->pid_file_pathspec = mfree(s->pid_file_pathspec);
153 }
154
155 static int service_set_main_pid(Service *s, pid_t pid) {
156 pid_t ppid;
157
158 assert(s);
159
160 if (pid <= 1)
161 return -EINVAL;
162
163 if (pid == getpid_cached())
164 return -EINVAL;
165
166 if (s->main_pid == pid && s->main_pid_known)
167 return 0;
168
169 if (s->main_pid != pid) {
170 service_unwatch_main_pid(s);
171 exec_status_start(&s->main_exec_status, pid);
172 }
173
174 s->main_pid = pid;
175 s->main_pid_known = true;
176
177 if (get_process_ppid(pid, &ppid) >= 0 && ppid != getpid_cached()) {
178 log_unit_warning(UNIT(s), "Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", pid);
179 s->main_pid_alien = true;
180 } else
181 s->main_pid_alien = false;
182
183 return 0;
184 }
185
186 void service_close_socket_fd(Service *s) {
187 assert(s);
188
189 /* Undo the effect of service_set_socket_fd(). */
190
191 s->socket_fd = asynchronous_close(s->socket_fd);
192
193 if (UNIT_ISSET(s->accept_socket)) {
194 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
195 unit_ref_unset(&s->accept_socket);
196 }
197 }
198
199 static void service_stop_watchdog(Service *s) {
200 assert(s);
201
202 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
203 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
204 }
205
206 static usec_t service_get_watchdog_usec(Service *s) {
207 assert(s);
208
209 if (s->watchdog_override_enable)
210 return s->watchdog_override_usec;
211 else
212 return s->watchdog_usec;
213 }
214
215 static void service_start_watchdog(Service *s) {
216 int r;
217 usec_t watchdog_usec;
218
219 assert(s);
220
221 watchdog_usec = service_get_watchdog_usec(s);
222 if (IN_SET(watchdog_usec, 0, USEC_INFINITY))
223 return;
224
225 if (s->watchdog_event_source) {
226 r = sd_event_source_set_time(s->watchdog_event_source, usec_add(s->watchdog_timestamp.monotonic, watchdog_usec));
227 if (r < 0) {
228 log_unit_warning_errno(UNIT(s), r, "Failed to reset watchdog timer: %m");
229 return;
230 }
231
232 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
233 } else {
234 r = sd_event_add_time(
235 UNIT(s)->manager->event,
236 &s->watchdog_event_source,
237 CLOCK_MONOTONIC,
238 usec_add(s->watchdog_timestamp.monotonic, watchdog_usec), 0,
239 service_dispatch_watchdog, s);
240 if (r < 0) {
241 log_unit_warning_errno(UNIT(s), r, "Failed to add watchdog timer: %m");
242 return;
243 }
244
245 (void) sd_event_source_set_description(s->watchdog_event_source, "service-watchdog");
246
247 /* Let's process everything else which might be a sign
248 * of living before we consider a service died. */
249 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
250 }
251
252 if (r < 0)
253 log_unit_warning_errno(UNIT(s), r, "Failed to install watchdog timer: %m");
254 }
255
256 static void service_extend_timeout(Service *s, usec_t extend_timeout_usec) {
257 assert(s);
258
259 if (s->timer_event_source) {
260 uint64_t current = 0, extended = 0;
261 int r;
262
263 if (IN_SET(extend_timeout_usec, 0, USEC_INFINITY))
264 return;
265
266 extended = usec_add(now(CLOCK_MONOTONIC), extend_timeout_usec);
267
268 r = sd_event_source_get_time(s->timer_event_source, &current);
269 if (r < 0)
270 log_unit_error_errno(UNIT(s), r, "Failed to retrieve timeout timer: %m");
271 else if (extended > current) {
272 r = sd_event_source_set_time(s->timer_event_source, extended);
273 if (r < 0)
274 log_unit_warning_errno(UNIT(s), r, "Failed to set timeout timer: %m");
275 }
276
277 if (s->watchdog_event_source) {
278 /* extend watchdog if necessary. We've asked for an extended timeout so we
279 * shouldn't expect a watchdog timeout in the interval in between */
280 r = sd_event_source_get_time(s->watchdog_event_source, &current);
281 if (r < 0) {
282 log_unit_error_errno(UNIT(s), r, "Failed to retrieve watchdog timer: %m");
283 return;
284 }
285
286 if (extended > current) {
287 r = sd_event_source_set_time(s->watchdog_event_source, extended);
288 if (r < 0)
289 log_unit_warning_errno(UNIT(s), r, "Failed to set watchdog timer: %m");
290 }
291 }
292 }
293 }
294
295 static void service_reset_watchdog(Service *s) {
296 assert(s);
297
298 dual_timestamp_get(&s->watchdog_timestamp);
299 service_start_watchdog(s);
300 }
301
302 static void service_reset_watchdog_timeout(Service *s, usec_t watchdog_override_usec) {
303 assert(s);
304
305 s->watchdog_override_enable = true;
306 s->watchdog_override_usec = watchdog_override_usec;
307 service_reset_watchdog(s);
308
309 log_unit_debug(UNIT(s), "watchdog_usec="USEC_FMT, s->watchdog_usec);
310 log_unit_debug(UNIT(s), "watchdog_override_usec="USEC_FMT, s->watchdog_override_usec);
311 }
312
313 static void service_fd_store_unlink(ServiceFDStore *fs) {
314
315 if (!fs)
316 return;
317
318 if (fs->service) {
319 assert(fs->service->n_fd_store > 0);
320 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
321 fs->service->n_fd_store--;
322 }
323
324 if (fs->event_source) {
325 sd_event_source_set_enabled(fs->event_source, SD_EVENT_OFF);
326 sd_event_source_unref(fs->event_source);
327 }
328
329 free(fs->fdname);
330 safe_close(fs->fd);
331 free(fs);
332 }
333
334 static void service_release_fd_store(Service *s) {
335 assert(s);
336
337 if (s->n_keep_fd_store > 0)
338 return;
339
340 log_unit_debug(UNIT(s), "Releasing all stored fds");
341 while (s->fd_store)
342 service_fd_store_unlink(s->fd_store);
343
344 assert(s->n_fd_store == 0);
345 }
346
347 static void service_release_resources(Unit *u) {
348 Service *s = SERVICE(u);
349
350 assert(s);
351
352 if (!s->fd_store && s->stdin_fd < 0 && s->stdout_fd < 0 && s->stderr_fd < 0)
353 return;
354
355 log_unit_debug(u, "Releasing resources.");
356
357 s->stdin_fd = safe_close(s->stdin_fd);
358 s->stdout_fd = safe_close(s->stdout_fd);
359 s->stderr_fd = safe_close(s->stderr_fd);
360
361 service_release_fd_store(s);
362 }
363
364 static void service_done(Unit *u) {
365 Service *s = SERVICE(u);
366
367 assert(s);
368
369 s->pid_file = mfree(s->pid_file);
370 s->status_text = mfree(s->status_text);
371
372 s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
373 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
374 s->control_command = NULL;
375 s->main_command = NULL;
376
377 dynamic_creds_unref(&s->dynamic_creds);
378
379 exit_status_set_free(&s->restart_prevent_status);
380 exit_status_set_free(&s->restart_force_status);
381 exit_status_set_free(&s->success_status);
382
383 /* This will leak a process, but at least no memory or any of
384 * our resources */
385 service_unwatch_main_pid(s);
386 service_unwatch_control_pid(s);
387 service_unwatch_pid_file(s);
388
389 if (s->bus_name) {
390 unit_unwatch_bus_name(u, s->bus_name);
391 s->bus_name = mfree(s->bus_name);
392 }
393
394 s->bus_name_owner = mfree(s->bus_name_owner);
395
396 service_close_socket_fd(s);
397 s->peer = socket_peer_unref(s->peer);
398
399 unit_ref_unset(&s->accept_socket);
400
401 service_stop_watchdog(s);
402
403 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
404
405 service_release_resources(u);
406 }
407
408 static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
409 ServiceFDStore *fs = userdata;
410
411 assert(e);
412 assert(fs);
413
414 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
415 log_unit_debug(UNIT(fs->service),
416 "Received %s on stored fd %d (%s), closing.",
417 revents & EPOLLERR ? "EPOLLERR" : "EPOLLHUP",
418 fs->fd, strna(fs->fdname));
419 service_fd_store_unlink(fs);
420 return 0;
421 }
422
423 static int service_add_fd_store(Service *s, int fd, const char *name) {
424 ServiceFDStore *fs;
425 int r;
426
427 /* fd is always consumed if we return >= 0 */
428
429 assert(s);
430 assert(fd >= 0);
431
432 if (s->n_fd_store >= s->n_fd_store_max)
433 return -EXFULL; /* Our store is full.
434 * Use this errno rather than E[NM]FILE to distinguish from
435 * the case where systemd itself hits the file limit. */
436
437 LIST_FOREACH(fd_store, fs, s->fd_store) {
438 r = same_fd(fs->fd, fd);
439 if (r < 0)
440 return r;
441 if (r > 0) {
442 safe_close(fd);
443 return 0; /* fd already included */
444 }
445 }
446
447 fs = new0(ServiceFDStore, 1);
448 if (!fs)
449 return -ENOMEM;
450
451 fs->fd = fd;
452 fs->service = s;
453 fs->fdname = strdup(name ?: "stored");
454 if (!fs->fdname) {
455 free(fs);
456 return -ENOMEM;
457 }
458
459 r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
460 if (r < 0 && r != -EPERM) { /* EPERM indicates fds that aren't pollable, which is OK */
461 free(fs->fdname);
462 free(fs);
463 return r;
464 } else if (r >= 0)
465 (void) sd_event_source_set_description(fs->event_source, "service-fd-store");
466
467 LIST_PREPEND(fd_store, s->fd_store, fs);
468 s->n_fd_store++;
469
470 return 1; /* fd newly stored */
471 }
472
473 static int service_add_fd_store_set(Service *s, FDSet *fds, const char *name) {
474 int r;
475
476 assert(s);
477
478 while (fdset_size(fds) > 0) {
479 _cleanup_close_ int fd = -1;
480
481 fd = fdset_steal_first(fds);
482 if (fd < 0)
483 break;
484
485 r = service_add_fd_store(s, fd, name);
486 if (r == -EXFULL)
487 return log_unit_warning_errno(UNIT(s), r,
488 "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
489 s->n_fd_store_max);
490 if (r < 0)
491 return log_unit_error_errno(UNIT(s), r, "Failed to add fd to store: %m");
492 if (r > 0)
493 log_unit_debug(UNIT(s), "Added fd %u (%s) to fd store.", fd, strna(name));
494 fd = -1;
495 }
496
497 return 0;
498 }
499
500 static void service_remove_fd_store(Service *s, const char *name) {
501 ServiceFDStore *fs, *n;
502
503 assert(s);
504 assert(name);
505
506 LIST_FOREACH_SAFE(fd_store, fs, n, s->fd_store) {
507 if (!streq(fs->fdname, name))
508 continue;
509
510 log_unit_debug(UNIT(s), "Got explicit request to remove fd %i (%s), closing.", fs->fd, name);
511 service_fd_store_unlink(fs);
512 }
513 }
514
515 static int service_arm_timer(Service *s, usec_t usec) {
516 int r;
517
518 assert(s);
519
520 if (s->timer_event_source) {
521 r = sd_event_source_set_time(s->timer_event_source, usec);
522 if (r < 0)
523 return r;
524
525 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
526 }
527
528 if (usec == USEC_INFINITY)
529 return 0;
530
531 r = sd_event_add_time(
532 UNIT(s)->manager->event,
533 &s->timer_event_source,
534 CLOCK_MONOTONIC,
535 usec, 0,
536 service_dispatch_timer, s);
537 if (r < 0)
538 return r;
539
540 (void) sd_event_source_set_description(s->timer_event_source, "service-timer");
541
542 return 0;
543 }
544
545 static int service_verify(Service *s) {
546 assert(s);
547
548 if (UNIT(s)->load_state != UNIT_LOADED)
549 return 0;
550
551 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
552 log_unit_error(UNIT(s), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
553 return -EINVAL;
554 }
555
556 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
557 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
558 return -EINVAL;
559 }
560
561 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
562 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
563 return -EINVAL;
564 }
565
566 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
567 log_unit_error(UNIT(s), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
568 return -EINVAL;
569 }
570
571 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
572 log_unit_error(UNIT(s), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
573 return -EINVAL;
574 }
575
576 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
577 log_unit_error(UNIT(s), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
578 return -EINVAL;
579 }
580
581 if (s->type == SERVICE_DBUS && !s->bus_name) {
582 log_unit_error(UNIT(s), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
583 return -EINVAL;
584 }
585
586 if (s->bus_name && s->type != SERVICE_DBUS)
587 log_unit_warning(UNIT(s), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
588
589 if (s->exec_context.pam_name && !IN_SET(s->kill_context.kill_mode, KILL_CONTROL_GROUP, KILL_MIXED)) {
590 log_unit_error(UNIT(s), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
591 return -EINVAL;
592 }
593
594 if (s->usb_function_descriptors && !s->usb_function_strings)
595 log_unit_warning(UNIT(s), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
596
597 if (!s->usb_function_descriptors && s->usb_function_strings)
598 log_unit_warning(UNIT(s), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
599
600 if (s->runtime_max_usec != USEC_INFINITY && s->type == SERVICE_ONESHOT)
601 log_unit_warning(UNIT(s), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
602
603 return 0;
604 }
605
606 static int service_add_default_dependencies(Service *s) {
607 int r;
608
609 assert(s);
610
611 if (!UNIT(s)->default_dependencies)
612 return 0;
613
614 /* Add a number of automatic dependencies useful for the
615 * majority of services. */
616
617 if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
618 /* First, pull in the really early boot stuff, and
619 * require it, so that we fail if we can't acquire
620 * it. */
621
622 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
623 if (r < 0)
624 return r;
625 } else {
626
627 /* In the --user instance there's no sysinit.target,
628 * in that case require basic.target instead. */
629
630 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
631 if (r < 0)
632 return r;
633 }
634
635 /* Second, if the rest of the base system is in the same
636 * transaction, order us after it, but do not pull it in or
637 * even require it. */
638 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_BASIC_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
639 if (r < 0)
640 return r;
641
642 /* Third, add us in for normal shutdown. */
643 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
644 }
645
646 static void service_fix_output(Service *s) {
647 assert(s);
648
649 /* If nothing has been explicitly configured, patch default output in. If input is socket/tty we avoid this
650 * however, since in that case we want output to default to the same place as we read input from. */
651
652 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
653 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
654 s->exec_context.std_input == EXEC_INPUT_NULL)
655 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
656
657 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
658 s->exec_context.std_input == EXEC_INPUT_NULL)
659 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
660
661 if (s->exec_context.std_input == EXEC_INPUT_NULL &&
662 s->exec_context.stdin_data_size > 0)
663 s->exec_context.std_input = EXEC_INPUT_DATA;
664 }
665
666 static int service_setup_bus_name(Service *s) {
667 int r;
668
669 assert(s);
670
671 if (!s->bus_name)
672 return 0;
673
674 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true, UNIT_DEPENDENCY_FILE);
675 if (r < 0)
676 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
677
678 /* We always want to be ordered against dbus.socket if both are in the transaction. */
679 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_DBUS_SOCKET, NULL, true, UNIT_DEPENDENCY_FILE);
680 if (r < 0)
681 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
682
683 r = unit_watch_bus_name(UNIT(s), s->bus_name);
684 if (r == -EEXIST)
685 return log_unit_error_errno(UNIT(s), r, "Two services allocated for the same bus name %s, refusing operation.", s->bus_name);
686 if (r < 0)
687 return log_unit_error_errno(UNIT(s), r, "Cannot watch bus name %s: %m", s->bus_name);
688
689 return 0;
690 }
691
692 static int service_add_extras(Service *s) {
693 int r;
694
695 assert(s);
696
697 if (s->type == _SERVICE_TYPE_INVALID) {
698 /* Figure out a type automatically */
699 if (s->bus_name)
700 s->type = SERVICE_DBUS;
701 else if (s->exec_command[SERVICE_EXEC_START])
702 s->type = SERVICE_SIMPLE;
703 else
704 s->type = SERVICE_ONESHOT;
705 }
706
707 /* Oneshot services have disabled start timeout by default */
708 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
709 s->timeout_start_usec = USEC_INFINITY;
710
711 service_fix_output(s);
712
713 r = unit_patch_contexts(UNIT(s));
714 if (r < 0)
715 return r;
716
717 r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
718 if (r < 0)
719 return r;
720
721 r = unit_set_default_slice(UNIT(s));
722 if (r < 0)
723 return r;
724
725 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
726 s->notify_access = NOTIFY_MAIN;
727
728 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
729 s->notify_access = NOTIFY_MAIN;
730
731 r = service_add_default_dependencies(s);
732 if (r < 0)
733 return r;
734
735 r = service_setup_bus_name(s);
736 if (r < 0)
737 return r;
738
739 return 0;
740 }
741
742 static int service_load(Unit *u) {
743 Service *s = SERVICE(u);
744 int r;
745
746 assert(s);
747
748 /* Load a .service file */
749 r = unit_load_fragment(u);
750 if (r < 0)
751 return r;
752
753 /* Still nothing found? Then let's give up */
754 if (u->load_state == UNIT_STUB)
755 return -ENOENT;
756
757 /* This is a new unit? Then let's add in some extras */
758 if (u->load_state == UNIT_LOADED) {
759
760 /* We were able to load something, then let's add in
761 * the dropin directories. */
762 r = unit_load_dropin(u);
763 if (r < 0)
764 return r;
765
766 /* This is a new unit? Then let's add in some
767 * extras */
768 r = service_add_extras(s);
769 if (r < 0)
770 return r;
771 }
772
773 return service_verify(s);
774 }
775
776 static void service_dump(Unit *u, FILE *f, const char *prefix) {
777 char buf_restart[FORMAT_TIMESPAN_MAX], buf_start[FORMAT_TIMESPAN_MAX], buf_stop[FORMAT_TIMESPAN_MAX];
778 char buf_runtime[FORMAT_TIMESPAN_MAX], buf_watchdog[FORMAT_TIMESPAN_MAX];
779 ServiceExecCommand c;
780 Service *s = SERVICE(u);
781 const char *prefix2;
782
783 assert(s);
784
785 prefix = strempty(prefix);
786 prefix2 = strjoina(prefix, "\t");
787
788 fprintf(f,
789 "%sService State: %s\n"
790 "%sResult: %s\n"
791 "%sReload Result: %s\n"
792 "%sPermissionsStartOnly: %s\n"
793 "%sRootDirectoryStartOnly: %s\n"
794 "%sRemainAfterExit: %s\n"
795 "%sGuessMainPID: %s\n"
796 "%sType: %s\n"
797 "%sRestart: %s\n"
798 "%sNotifyAccess: %s\n"
799 "%sNotifyState: %s\n",
800 prefix, service_state_to_string(s->state),
801 prefix, service_result_to_string(s->result),
802 prefix, service_result_to_string(s->reload_result),
803 prefix, yes_no(s->permissions_start_only),
804 prefix, yes_no(s->root_directory_start_only),
805 prefix, yes_no(s->remain_after_exit),
806 prefix, yes_no(s->guess_main_pid),
807 prefix, service_type_to_string(s->type),
808 prefix, service_restart_to_string(s->restart),
809 prefix, notify_access_to_string(s->notify_access),
810 prefix, notify_state_to_string(s->notify_state));
811
812 if (s->control_pid > 0)
813 fprintf(f,
814 "%sControl PID: "PID_FMT"\n",
815 prefix, s->control_pid);
816
817 if (s->main_pid > 0)
818 fprintf(f,
819 "%sMain PID: "PID_FMT"\n"
820 "%sMain PID Known: %s\n"
821 "%sMain PID Alien: %s\n",
822 prefix, s->main_pid,
823 prefix, yes_no(s->main_pid_known),
824 prefix, yes_no(s->main_pid_alien));
825
826 if (s->pid_file)
827 fprintf(f,
828 "%sPIDFile: %s\n",
829 prefix, s->pid_file);
830
831 if (s->bus_name)
832 fprintf(f,
833 "%sBusName: %s\n"
834 "%sBus Name Good: %s\n",
835 prefix, s->bus_name,
836 prefix, yes_no(s->bus_name_good));
837
838 if (UNIT_ISSET(s->accept_socket))
839 fprintf(f,
840 "%sAccept Socket: %s\n",
841 prefix, UNIT_DEREF(s->accept_socket)->id);
842
843 fprintf(f,
844 "%sRestartSec: %s\n"
845 "%sTimeoutStartSec: %s\n"
846 "%sTimeoutStopSec: %s\n"
847 "%sRuntimeMaxSec: %s\n"
848 "%sWatchdogSec: %s\n",
849 prefix, format_timespan(buf_restart, sizeof(buf_restart), s->restart_usec, USEC_PER_SEC),
850 prefix, format_timespan(buf_start, sizeof(buf_start), s->timeout_start_usec, USEC_PER_SEC),
851 prefix, format_timespan(buf_stop, sizeof(buf_stop), s->timeout_stop_usec, USEC_PER_SEC),
852 prefix, format_timespan(buf_runtime, sizeof(buf_runtime), s->runtime_max_usec, USEC_PER_SEC),
853 prefix, format_timespan(buf_watchdog, sizeof(buf_watchdog), s->watchdog_usec, USEC_PER_SEC));
854
855 kill_context_dump(&s->kill_context, f, prefix);
856 exec_context_dump(&s->exec_context, f, prefix);
857
858 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
859
860 if (!s->exec_command[c])
861 continue;
862
863 fprintf(f, "%s-> %s:\n",
864 prefix, service_exec_command_to_string(c));
865
866 exec_command_dump_list(s->exec_command[c], f, prefix2);
867 }
868
869 if (s->status_text)
870 fprintf(f, "%sStatus Text: %s\n",
871 prefix, s->status_text);
872
873 if (s->n_fd_store_max > 0)
874 fprintf(f,
875 "%sFile Descriptor Store Max: %u\n"
876 "%sFile Descriptor Store Current: %u\n",
877 prefix, s->n_fd_store_max,
878 prefix, s->n_fd_store);
879
880 cgroup_context_dump(&s->cgroup_context, f, prefix);
881 }
882
883 static int service_is_suitable_main_pid(Service *s, pid_t pid, int prio) {
884 Unit *owner;
885
886 assert(s);
887 assert(pid_is_valid(pid));
888
889 /* Checks whether the specified PID is suitable as main PID for this service. returns negative if not, 0 if the
890 * PID is questionnable but should be accepted if the source of configuration is trusted. > 0 if the PID is
891 * good */
892
893 if (pid == getpid_cached() || pid == 1) {
894 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the manager, refusing.", pid);
895 return -EPERM;
896 }
897
898 if (pid == s->control_pid) {
899 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the control process, refusing.", pid);
900 return -EPERM;
901 }
902
903 if (!pid_is_alive(pid)) {
904 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" does not exist or is a zombie.", pid);
905 return -ESRCH;
906 }
907
908 owner = manager_get_unit_by_pid(UNIT(s)->manager, pid);
909 if (owner == UNIT(s)) {
910 log_unit_debug(UNIT(s), "New main PID "PID_FMT" belongs to service, we are happy.", pid);
911 return 1; /* Yay, it's definitely a good PID */
912 }
913
914 return 0; /* Hmm it's a suspicious PID, let's accept it if configuration source is trusted */
915 }
916
917 static int service_load_pid_file(Service *s, bool may_warn) {
918 char procfs[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
919 bool questionable_pid_file = false;
920 _cleanup_free_ char *k = NULL;
921 _cleanup_close_ int fd = -1;
922 int r, prio;
923 pid_t pid;
924
925 assert(s);
926
927 if (!s->pid_file)
928 return -ENOENT;
929
930 prio = may_warn ? LOG_INFO : LOG_DEBUG;
931
932 fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN|CHASE_SAFE, NULL);
933 if (fd == -EPERM) {
934 log_unit_full(UNIT(s), LOG_DEBUG, fd, "Permission denied while opening PID file or potentially unsafe symlink chain, will now retry with relaxed checks: %s", s->pid_file);
935
936 questionable_pid_file = true;
937
938 fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN, NULL);
939 }
940 if (fd < 0)
941 return log_unit_full(UNIT(s), prio, fd, "Can't open PID file %s (yet?) after %s: %m", s->pid_file, service_state_to_string(s->state));
942
943 /* Let's read the PID file now that we chased it down. But we need to convert the O_PATH fd chase_symlinks() returned us into a proper fd first. */
944 xsprintf(procfs, "/proc/self/fd/%i", fd);
945 r = read_one_line_file(procfs, &k);
946 if (r < 0)
947 return log_unit_error_errno(UNIT(s), r, "Can't convert PID files %s O_PATH file descriptor to proper file descriptor: %m", s->pid_file);
948
949 r = parse_pid(k, &pid);
950 if (r < 0)
951 return log_unit_full(UNIT(s), prio, r, "Failed to parse PID from file %s: %m", s->pid_file);
952
953 if (s->main_pid_known && pid == s->main_pid)
954 return 0;
955
956 r = service_is_suitable_main_pid(s, pid, prio);
957 if (r < 0)
958 return r;
959 if (r == 0) {
960 struct stat st;
961
962 if (questionable_pid_file) {
963 log_unit_error(UNIT(s), "Refusing to accept PID outside of service control group, acquired through unsafe symlink chain: %s", s->pid_file);
964 return -EPERM;
965 }
966
967 /* Hmm, it's not clear if the new main PID is safe. Let's allow this if the PID file is owned by root */
968
969 if (fstat(fd, &st) < 0)
970 return log_unit_error_errno(UNIT(s), errno, "Failed to fstat() PID file O_PATH fd: %m");
971
972 if (st.st_uid != 0) {
973 log_unit_error(UNIT(s), "New main PID "PID_FMT" does not belong to service, and PID file is not owned by root. Refusing.", pid);
974 return -EPERM;
975 }
976
977 log_unit_debug(UNIT(s), "New main PID "PID_FMT" does not belong to service, but we'll accept it since PID file is owned by root.", pid);
978 }
979
980 if (s->main_pid_known) {
981 log_unit_debug(UNIT(s), "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
982
983 service_unwatch_main_pid(s);
984 s->main_pid_known = false;
985 } else
986 log_unit_debug(UNIT(s), "Main PID loaded: "PID_FMT, pid);
987
988 r = service_set_main_pid(s, pid);
989 if (r < 0)
990 return r;
991
992 r = unit_watch_pid(UNIT(s), pid);
993 if (r < 0) /* FIXME: we need to do something here */
994 return log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" for service: %m", pid);
995
996 return 1;
997 }
998
999 static void service_search_main_pid(Service *s) {
1000 pid_t pid = 0;
1001 int r;
1002
1003 assert(s);
1004
1005 /* If we know it anyway, don't ever fallback to unreliable
1006 * heuristics */
1007 if (s->main_pid_known)
1008 return;
1009
1010 if (!s->guess_main_pid)
1011 return;
1012
1013 assert(s->main_pid <= 0);
1014
1015 if (unit_search_main_pid(UNIT(s), &pid) < 0)
1016 return;
1017
1018 log_unit_debug(UNIT(s), "Main PID guessed: "PID_FMT, pid);
1019 if (service_set_main_pid(s, pid) < 0)
1020 return;
1021
1022 r = unit_watch_pid(UNIT(s), pid);
1023 if (r < 0)
1024 /* FIXME: we need to do something here */
1025 log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" from: %m", pid);
1026 }
1027
1028 static void service_set_state(Service *s, ServiceState state) {
1029 ServiceState old_state;
1030 const UnitActiveState *table;
1031
1032 assert(s);
1033
1034 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1035
1036 old_state = s->state;
1037 s->state = state;
1038
1039 service_unwatch_pid_file(s);
1040
1041 if (!IN_SET(state,
1042 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1043 SERVICE_RUNNING,
1044 SERVICE_RELOAD,
1045 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1046 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1047 SERVICE_AUTO_RESTART))
1048 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1049
1050 if (!IN_SET(state,
1051 SERVICE_START, SERVICE_START_POST,
1052 SERVICE_RUNNING, SERVICE_RELOAD,
1053 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1054 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1055 service_unwatch_main_pid(s);
1056 s->main_command = NULL;
1057 }
1058
1059 if (!IN_SET(state,
1060 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1061 SERVICE_RELOAD,
1062 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1063 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1064 service_unwatch_control_pid(s);
1065 s->control_command = NULL;
1066 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1067 }
1068
1069 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1070 unit_unwatch_all_pids(UNIT(s));
1071
1072 if (!IN_SET(state,
1073 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1074 SERVICE_RUNNING, SERVICE_RELOAD,
1075 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1076 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1077 !(state == SERVICE_DEAD && UNIT(s)->job))
1078 service_close_socket_fd(s);
1079
1080 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1081 service_stop_watchdog(s);
1082
1083 /* For the inactive states unit_notify() will trim the cgroup,
1084 * but for exit we have to do that ourselves... */
1085 if (state == SERVICE_EXITED && !MANAGER_IS_RELOADING(UNIT(s)->manager))
1086 unit_prune_cgroup(UNIT(s));
1087
1088 if (old_state != state)
1089 log_unit_debug(UNIT(s), "Changed %s -> %s", service_state_to_string(old_state), service_state_to_string(state));
1090
1091 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1092 }
1093
1094 static usec_t service_coldplug_timeout(Service *s) {
1095 assert(s);
1096
1097 switch (s->deserialized_state) {
1098
1099 case SERVICE_START_PRE:
1100 case SERVICE_START:
1101 case SERVICE_START_POST:
1102 case SERVICE_RELOAD:
1103 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_start_usec);
1104
1105 case SERVICE_RUNNING:
1106 return usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec);
1107
1108 case SERVICE_STOP:
1109 case SERVICE_STOP_SIGABRT:
1110 case SERVICE_STOP_SIGTERM:
1111 case SERVICE_STOP_SIGKILL:
1112 case SERVICE_STOP_POST:
1113 case SERVICE_FINAL_SIGTERM:
1114 case SERVICE_FINAL_SIGKILL:
1115 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_stop_usec);
1116
1117 case SERVICE_AUTO_RESTART:
1118 return usec_add(UNIT(s)->inactive_enter_timestamp.monotonic, s->restart_usec);
1119
1120 default:
1121 return USEC_INFINITY;
1122 }
1123 }
1124
1125 static int service_coldplug(Unit *u) {
1126 Service *s = SERVICE(u);
1127 int r;
1128
1129 assert(s);
1130 assert(s->state == SERVICE_DEAD);
1131
1132 if (s->deserialized_state == s->state)
1133 return 0;
1134
1135 r = service_arm_timer(s, service_coldplug_timeout(s));
1136 if (r < 0)
1137 return r;
1138
1139 if (s->main_pid > 0 &&
1140 pid_is_unwaited(s->main_pid) &&
1141 (IN_SET(s->deserialized_state,
1142 SERVICE_START, SERVICE_START_POST,
1143 SERVICE_RUNNING, SERVICE_RELOAD,
1144 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1145 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1146 r = unit_watch_pid(UNIT(s), s->main_pid);
1147 if (r < 0)
1148 return r;
1149 }
1150
1151 if (s->control_pid > 0 &&
1152 pid_is_unwaited(s->control_pid) &&
1153 IN_SET(s->deserialized_state,
1154 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1155 SERVICE_RELOAD,
1156 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1157 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1158 r = unit_watch_pid(UNIT(s), s->control_pid);
1159 if (r < 0)
1160 return r;
1161 }
1162
1163 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1164 unit_watch_all_pids(UNIT(s));
1165
1166 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1167 service_start_watchdog(s);
1168
1169 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
1170 (void) unit_setup_dynamic_creds(u);
1171 (void) unit_setup_exec_runtime(u);
1172 }
1173
1174 if (UNIT_ISSET(s->accept_socket)) {
1175 Socket* socket = SOCKET(UNIT_DEREF(s->accept_socket));
1176
1177 if (socket->max_connections_per_source > 0) {
1178 SocketPeer *peer;
1179
1180 /* Make a best-effort attempt at bumping the connection count */
1181 if (socket_acquire_peer(socket, s->socket_fd, &peer) > 0) {
1182 socket_peer_unref(s->peer);
1183 s->peer = peer;
1184 }
1185 }
1186 }
1187
1188 service_set_state(s, s->deserialized_state);
1189 return 0;
1190 }
1191
1192 static int service_collect_fds(Service *s,
1193 int **fds,
1194 char ***fd_names,
1195 unsigned *n_storage_fds,
1196 unsigned *n_socket_fds) {
1197
1198 _cleanup_strv_free_ char **rfd_names = NULL;
1199 _cleanup_free_ int *rfds = NULL;
1200 unsigned rn_socket_fds = 0, rn_storage_fds = 0;
1201 int r;
1202
1203 assert(s);
1204 assert(fds);
1205 assert(fd_names);
1206 assert(n_socket_fds);
1207
1208 if (s->socket_fd >= 0) {
1209
1210 /* Pass the per-connection socket */
1211
1212 rfds = new(int, 1);
1213 if (!rfds)
1214 return -ENOMEM;
1215 rfds[0] = s->socket_fd;
1216
1217 rfd_names = strv_new("connection", NULL);
1218 if (!rfd_names)
1219 return -ENOMEM;
1220
1221 rn_socket_fds = 1;
1222 } else {
1223 Iterator i;
1224 void *v;
1225 Unit *u;
1226
1227 /* Pass all our configured sockets for singleton services */
1228
1229 HASHMAP_FOREACH_KEY(v, u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1230 _cleanup_free_ int *cfds = NULL;
1231 Socket *sock;
1232 int cn_fds;
1233
1234 if (u->type != UNIT_SOCKET)
1235 continue;
1236
1237 sock = SOCKET(u);
1238
1239 cn_fds = socket_collect_fds(sock, &cfds);
1240 if (cn_fds < 0)
1241 return cn_fds;
1242
1243 if (cn_fds <= 0)
1244 continue;
1245
1246 if (!rfds) {
1247 rfds = cfds;
1248 rn_socket_fds = cn_fds;
1249
1250 cfds = NULL;
1251 } else {
1252 int *t;
1253
1254 t = realloc(rfds, (rn_socket_fds + cn_fds) * sizeof(int));
1255 if (!t)
1256 return -ENOMEM;
1257
1258 memcpy(t + rn_socket_fds, cfds, cn_fds * sizeof(int));
1259
1260 rfds = t;
1261 rn_socket_fds += cn_fds;
1262 }
1263
1264 r = strv_extend_n(&rfd_names, socket_fdname(sock), cn_fds);
1265 if (r < 0)
1266 return r;
1267 }
1268 }
1269
1270 if (s->n_fd_store > 0) {
1271 ServiceFDStore *fs;
1272 unsigned n_fds;
1273 char **nl;
1274 int *t;
1275
1276 t = realloc(rfds, (rn_socket_fds + s->n_fd_store) * sizeof(int));
1277 if (!t)
1278 return -ENOMEM;
1279
1280 rfds = t;
1281
1282 nl = realloc(rfd_names, (rn_socket_fds + s->n_fd_store + 1) * sizeof(char*));
1283 if (!nl)
1284 return -ENOMEM;
1285
1286 rfd_names = nl;
1287 n_fds = rn_socket_fds;
1288
1289 LIST_FOREACH(fd_store, fs, s->fd_store) {
1290 rfds[n_fds] = fs->fd;
1291 rfd_names[n_fds] = strdup(strempty(fs->fdname));
1292 if (!rfd_names[n_fds])
1293 return -ENOMEM;
1294
1295 rn_storage_fds++;
1296 n_fds++;
1297 }
1298
1299 rfd_names[n_fds] = NULL;
1300 }
1301
1302 *fds = rfds;
1303 *fd_names = rfd_names;
1304 *n_socket_fds = rn_socket_fds;
1305 *n_storage_fds = rn_storage_fds;
1306
1307 rfds = NULL;
1308 rfd_names = NULL;
1309
1310 return 0;
1311 }
1312
1313 static bool service_exec_needs_notify_socket(Service *s, ExecFlags flags) {
1314 assert(s);
1315
1316 /* Notifications are accepted depending on the process and
1317 * the access setting of the service:
1318 * process: \ access: NONE MAIN EXEC ALL
1319 * main no yes yes yes
1320 * control no no yes yes
1321 * other (forked) no no no yes */
1322
1323 if (flags & EXEC_IS_CONTROL)
1324 /* A control process */
1325 return IN_SET(s->notify_access, NOTIFY_EXEC, NOTIFY_ALL);
1326
1327 /* We only spawn main processes and control processes, so any
1328 * process that is not a control process is a main process */
1329 return s->notify_access != NOTIFY_NONE;
1330 }
1331
1332 static int service_spawn(
1333 Service *s,
1334 ExecCommand *c,
1335 usec_t timeout,
1336 ExecFlags flags,
1337 pid_t *_pid) {
1338
1339 ExecParameters exec_params = {
1340 .flags = flags,
1341 .stdin_fd = -1,
1342 .stdout_fd = -1,
1343 .stderr_fd = -1,
1344 };
1345 _cleanup_strv_free_ char **final_env = NULL, **our_env = NULL, **fd_names = NULL;
1346 unsigned n_storage_fds = 0, n_socket_fds = 0, n_env = 0;
1347 _cleanup_free_ int *fds = NULL;
1348 pid_t pid;
1349 int r;
1350
1351 assert(s);
1352 assert(c);
1353 assert(_pid);
1354
1355 r = unit_prepare_exec(UNIT(s));
1356 if (r < 0)
1357 return r;
1358
1359 if (flags & EXEC_IS_CONTROL) {
1360 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1361 if (s->permissions_start_only)
1362 exec_params.flags &= ~EXEC_APPLY_SANDBOXING;
1363 if (s->root_directory_start_only)
1364 exec_params.flags &= ~EXEC_APPLY_CHROOT;
1365 }
1366
1367 if ((flags & EXEC_PASS_FDS) ||
1368 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1369 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1370 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1371
1372 r = service_collect_fds(s, &fds, &fd_names, &n_storage_fds, &n_socket_fds);
1373 if (r < 0)
1374 return r;
1375
1376 log_unit_debug(UNIT(s), "Passing %i fds to service", n_storage_fds + n_socket_fds);
1377 }
1378
1379 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), timeout));
1380 if (r < 0)
1381 return r;
1382
1383 our_env = new0(char*, 9);
1384 if (!our_env)
1385 return -ENOMEM;
1386
1387 if (service_exec_needs_notify_socket(s, flags))
1388 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0)
1389 return -ENOMEM;
1390
1391 if (s->main_pid > 0)
1392 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0)
1393 return -ENOMEM;
1394
1395 if (MANAGER_IS_USER(UNIT(s)->manager))
1396 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid_cached()) < 0)
1397 return -ENOMEM;
1398
1399 if (s->socket_fd >= 0) {
1400 union sockaddr_union sa;
1401 socklen_t salen = sizeof(sa);
1402
1403 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1404 * useful. Note that we do this only when we are still connected at this point in time, which we might
1405 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1406 * in ENOTCONN), and just use whate we can use. */
1407
1408 if (getpeername(s->socket_fd, &sa.sa, &salen) >= 0 &&
1409 IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
1410
1411 _cleanup_free_ char *addr = NULL;
1412 char *t;
1413 unsigned port;
1414
1415 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1416 if (r < 0)
1417 return r;
1418
1419 t = strappend("REMOTE_ADDR=", addr);
1420 if (!t)
1421 return -ENOMEM;
1422 our_env[n_env++] = t;
1423
1424 r = sockaddr_port(&sa.sa, &port);
1425 if (r < 0)
1426 return r;
1427
1428 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
1429 return -ENOMEM;
1430 our_env[n_env++] = t;
1431 }
1432 }
1433
1434 if (flags & EXEC_SETENV_RESULT) {
1435 if (asprintf(our_env + n_env++, "SERVICE_RESULT=%s", service_result_to_string(s->result)) < 0)
1436 return -ENOMEM;
1437
1438 if (s->main_exec_status.pid > 0 &&
1439 dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1440 if (asprintf(our_env + n_env++, "EXIT_CODE=%s", sigchld_code_to_string(s->main_exec_status.code)) < 0)
1441 return -ENOMEM;
1442
1443 if (s->main_exec_status.code == CLD_EXITED)
1444 r = asprintf(our_env + n_env++, "EXIT_STATUS=%i", s->main_exec_status.status);
1445 else
1446 r = asprintf(our_env + n_env++, "EXIT_STATUS=%s", signal_to_string(s->main_exec_status.status));
1447 if (r < 0)
1448 return -ENOMEM;
1449 }
1450 }
1451
1452 unit_set_exec_params(UNIT(s), &exec_params);
1453
1454 final_env = strv_env_merge(2, exec_params.environment, our_env, NULL);
1455 if (!final_env)
1456 return -ENOMEM;
1457
1458 /* System services should get a new keyring by default. */
1459 SET_FLAG(exec_params.flags, EXEC_NEW_KEYRING, MANAGER_IS_SYSTEM(UNIT(s)->manager));
1460
1461 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1462 SET_FLAG(exec_params.flags, EXEC_NSS_BYPASS_BUS,
1463 MANAGER_IS_SYSTEM(UNIT(s)->manager) && unit_has_name(UNIT(s), SPECIAL_DBUS_SERVICE));
1464
1465 exec_params.argv = c->argv;
1466 exec_params.environment = final_env;
1467 exec_params.fds = fds;
1468 exec_params.fd_names = fd_names;
1469 exec_params.n_storage_fds = n_storage_fds;
1470 exec_params.n_socket_fds = n_socket_fds;
1471 exec_params.watchdog_usec = s->watchdog_usec;
1472 exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
1473 if (s->type == SERVICE_IDLE)
1474 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1475 exec_params.stdin_fd = s->stdin_fd;
1476 exec_params.stdout_fd = s->stdout_fd;
1477 exec_params.stderr_fd = s->stderr_fd;
1478
1479 r = exec_spawn(UNIT(s),
1480 c,
1481 &s->exec_context,
1482 &exec_params,
1483 s->exec_runtime,
1484 &s->dynamic_creds,
1485 &pid);
1486 if (r < 0)
1487 return r;
1488
1489 r = unit_watch_pid(UNIT(s), pid);
1490 if (r < 0) /* FIXME: we need to do something here */
1491 return r;
1492
1493 *_pid = pid;
1494
1495 return 0;
1496 }
1497
1498 static int main_pid_good(Service *s) {
1499 assert(s);
1500
1501 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1502
1503 /* If we know the pid file, then let's just check if it is
1504 * still valid */
1505 if (s->main_pid_known) {
1506
1507 /* If it's an alien child let's check if it is still
1508 * alive ... */
1509 if (s->main_pid_alien && s->main_pid > 0)
1510 return pid_is_alive(s->main_pid);
1511
1512 /* .. otherwise assume we'll get a SIGCHLD for it,
1513 * which we really should wait for to collect exit
1514 * status and code */
1515 return s->main_pid > 0;
1516 }
1517
1518 /* We don't know the pid */
1519 return -EAGAIN;
1520 }
1521
1522 static int control_pid_good(Service *s) {
1523 assert(s);
1524
1525 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1526 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1527 * means: we can't figure it out. */
1528
1529 return s->control_pid > 0;
1530 }
1531
1532 static int cgroup_good(Service *s) {
1533 int r;
1534
1535 assert(s);
1536
1537 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1538 * figure it out */
1539
1540 if (!UNIT(s)->cgroup_path)
1541 return 0;
1542
1543 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path);
1544 if (r < 0)
1545 return r;
1546
1547 return r == 0;
1548 }
1549
1550 static bool service_shall_restart(Service *s) {
1551 assert(s);
1552
1553 /* Don't restart after manual stops */
1554 if (s->forbid_restart)
1555 return false;
1556
1557 /* Never restart if this is configured as special exception */
1558 if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status))
1559 return false;
1560
1561 /* Restart if the exit code/status are configured as restart triggers */
1562 if (exit_status_set_test(&s->restart_force_status, s->main_exec_status.code, s->main_exec_status.status))
1563 return true;
1564
1565 switch (s->restart) {
1566
1567 case SERVICE_RESTART_NO:
1568 return false;
1569
1570 case SERVICE_RESTART_ALWAYS:
1571 return true;
1572
1573 case SERVICE_RESTART_ON_SUCCESS:
1574 return s->result == SERVICE_SUCCESS;
1575
1576 case SERVICE_RESTART_ON_FAILURE:
1577 return s->result != SERVICE_SUCCESS;
1578
1579 case SERVICE_RESTART_ON_ABNORMAL:
1580 return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE);
1581
1582 case SERVICE_RESTART_ON_WATCHDOG:
1583 return s->result == SERVICE_FAILURE_WATCHDOG;
1584
1585 case SERVICE_RESTART_ON_ABORT:
1586 return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
1587
1588 default:
1589 assert_not_reached("unknown restart setting");
1590 }
1591 }
1592
1593 static bool service_will_restart(Unit *u) {
1594 Service *s = SERVICE(u);
1595
1596 assert(s);
1597
1598 if (s->will_auto_restart)
1599 return true;
1600 if (s->state == SERVICE_AUTO_RESTART)
1601 return true;
1602 if (!UNIT(s)->job)
1603 return false;
1604 if (UNIT(s)->job->type == JOB_START)
1605 return true;
1606 return false;
1607 }
1608
1609 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1610 int r;
1611
1612 assert(s);
1613
1614 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1615 * undo what has already been enqueued. */
1616 if (unit_stop_pending(UNIT(s)))
1617 allow_restart = false;
1618
1619 if (s->result == SERVICE_SUCCESS)
1620 s->result = f;
1621
1622 if (s->result != SERVICE_SUCCESS)
1623 log_unit_warning(UNIT(s), "Failed with result '%s'.", service_result_to_string(s->result));
1624
1625 if (allow_restart && service_shall_restart(s))
1626 s->will_auto_restart = true;
1627
1628 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1629 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1630 s->n_keep_fd_store ++;
1631
1632 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1633
1634 if (s->will_auto_restart) {
1635 s->will_auto_restart = false;
1636
1637 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1638 if (r < 0) {
1639 s->n_keep_fd_store--;
1640 goto fail;
1641 }
1642
1643 service_set_state(s, SERVICE_AUTO_RESTART);
1644 } else
1645 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1646 * user can still introspect the counter. Do so on the next start. */
1647 s->flush_n_restarts = true;
1648
1649 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1650 * queue, so that the fd store is possibly gc'ed again */
1651 s->n_keep_fd_store--;
1652 unit_add_to_gc_queue(UNIT(s));
1653
1654 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1655 s->forbid_restart = false;
1656
1657 /* We want fresh tmpdirs in case service is started again immediately */
1658 s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
1659
1660 if (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_NO ||
1661 (s->exec_context.runtime_directory_preserve_mode == EXEC_PRESERVE_RESTART && !service_will_restart(UNIT(s))))
1662 /* Also, remove the runtime directory */
1663 exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
1664
1665 /* Get rid of the IPC bits of the user */
1666 unit_unref_uid_gid(UNIT(s), true);
1667
1668 /* Release the user, and destroy it if we are the only remaining owner */
1669 dynamic_creds_destroy(&s->dynamic_creds);
1670
1671 /* Try to delete the pid file. At this point it will be
1672 * out-of-date, and some software might be confused by it, so
1673 * let's remove it. */
1674 if (s->pid_file)
1675 (void) unlink(s->pid_file);
1676
1677 return;
1678
1679 fail:
1680 log_unit_warning_errno(UNIT(s), r, "Failed to run install restart timer: %m");
1681 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1682 }
1683
1684 static void service_enter_stop_post(Service *s, ServiceResult f) {
1685 int r;
1686 assert(s);
1687
1688 if (s->result == SERVICE_SUCCESS)
1689 s->result = f;
1690
1691 service_unwatch_control_pid(s);
1692 unit_watch_all_pids(UNIT(s));
1693
1694 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1695 if (s->control_command) {
1696 s->control_command_id = SERVICE_EXEC_STOP_POST;
1697
1698 r = service_spawn(s,
1699 s->control_command,
1700 s->timeout_stop_usec,
1701 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1702 &s->control_pid);
1703 if (r < 0)
1704 goto fail;
1705
1706 service_set_state(s, SERVICE_STOP_POST);
1707 } else
1708 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1709
1710 return;
1711
1712 fail:
1713 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
1714 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1715 }
1716
1717 static int state_to_kill_operation(ServiceState state) {
1718 switch (state) {
1719
1720 case SERVICE_STOP_SIGABRT:
1721 return KILL_ABORT;
1722
1723 case SERVICE_STOP_SIGTERM:
1724 case SERVICE_FINAL_SIGTERM:
1725 return KILL_TERMINATE;
1726
1727 case SERVICE_STOP_SIGKILL:
1728 case SERVICE_FINAL_SIGKILL:
1729 return KILL_KILL;
1730
1731 default:
1732 return _KILL_OPERATION_INVALID;
1733 }
1734 }
1735
1736 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1737 int r;
1738
1739 assert(s);
1740
1741 if (s->result == SERVICE_SUCCESS)
1742 s->result = f;
1743
1744 unit_watch_all_pids(UNIT(s));
1745
1746 r = unit_kill_context(
1747 UNIT(s),
1748 &s->kill_context,
1749 state_to_kill_operation(state),
1750 s->main_pid,
1751 s->control_pid,
1752 s->main_pid_alien);
1753 if (r < 0)
1754 goto fail;
1755
1756 if (r > 0) {
1757 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1758 if (r < 0)
1759 goto fail;
1760
1761 service_set_state(s, state);
1762 } else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
1763 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1764 else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1765 service_enter_stop_post(s, SERVICE_SUCCESS);
1766 else if (state == SERVICE_FINAL_SIGTERM && s->kill_context.send_sigkill)
1767 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1768 else
1769 service_enter_dead(s, SERVICE_SUCCESS, true);
1770
1771 return;
1772
1773 fail:
1774 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
1775
1776 if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1777 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1778 else
1779 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1780 }
1781
1782 static void service_enter_stop_by_notify(Service *s) {
1783 assert(s);
1784
1785 unit_watch_all_pids(UNIT(s));
1786
1787 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1788
1789 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1790 service_set_state(s, SERVICE_STOP_SIGTERM);
1791 }
1792
1793 static void service_enter_stop(Service *s, ServiceResult f) {
1794 int r;
1795
1796 assert(s);
1797
1798 if (s->result == SERVICE_SUCCESS)
1799 s->result = f;
1800
1801 service_unwatch_control_pid(s);
1802 unit_watch_all_pids(UNIT(s));
1803
1804 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1805 if (s->control_command) {
1806 s->control_command_id = SERVICE_EXEC_STOP;
1807
1808 r = service_spawn(s,
1809 s->control_command,
1810 s->timeout_stop_usec,
1811 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_SETENV_RESULT,
1812 &s->control_pid);
1813 if (r < 0)
1814 goto fail;
1815
1816 service_set_state(s, SERVICE_STOP);
1817 } else
1818 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1819
1820 return;
1821
1822 fail:
1823 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop' task: %m");
1824 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1825 }
1826
1827 static bool service_good(Service *s) {
1828 int main_pid_ok;
1829 assert(s);
1830
1831 if (s->type == SERVICE_DBUS && !s->bus_name_good)
1832 return false;
1833
1834 main_pid_ok = main_pid_good(s);
1835 if (main_pid_ok > 0) /* It's alive */
1836 return true;
1837 if (main_pid_ok == 0) /* It's dead */
1838 return false;
1839
1840 /* OK, we don't know anything about the main PID, maybe
1841 * because there is none. Let's check the control group
1842 * instead. */
1843
1844 return cgroup_good(s) != 0;
1845 }
1846
1847 static void service_enter_running(Service *s, ServiceResult f) {
1848 assert(s);
1849
1850 if (s->result == SERVICE_SUCCESS)
1851 s->result = f;
1852
1853 service_unwatch_control_pid(s);
1854
1855 if (service_good(s)) {
1856
1857 /* If there are any queued up sd_notify()
1858 * notifications, process them now */
1859 if (s->notify_state == NOTIFY_RELOADING)
1860 service_enter_reload_by_notify(s);
1861 else if (s->notify_state == NOTIFY_STOPPING)
1862 service_enter_stop_by_notify(s);
1863 else {
1864 service_set_state(s, SERVICE_RUNNING);
1865 service_arm_timer(s, usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec));
1866 }
1867
1868 } else if (f != SERVICE_SUCCESS)
1869 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
1870 else if (s->remain_after_exit)
1871 service_set_state(s, SERVICE_EXITED);
1872 else
1873 service_enter_stop(s, SERVICE_SUCCESS);
1874 }
1875
1876 static void service_enter_start_post(Service *s) {
1877 int r;
1878 assert(s);
1879
1880 service_unwatch_control_pid(s);
1881 service_reset_watchdog(s);
1882
1883 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1884 if (s->control_command) {
1885 s->control_command_id = SERVICE_EXEC_START_POST;
1886
1887 r = service_spawn(s,
1888 s->control_command,
1889 s->timeout_start_usec,
1890 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
1891 &s->control_pid);
1892 if (r < 0)
1893 goto fail;
1894
1895 service_set_state(s, SERVICE_START_POST);
1896 } else
1897 service_enter_running(s, SERVICE_SUCCESS);
1898
1899 return;
1900
1901 fail:
1902 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
1903 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1904 }
1905
1906 static void service_kill_control_process(Service *s) {
1907 int r;
1908
1909 assert(s);
1910
1911 if (s->control_pid <= 0)
1912 return;
1913
1914 r = kill_and_sigcont(s->control_pid, SIGKILL);
1915 if (r < 0) {
1916 _cleanup_free_ char *comm = NULL;
1917
1918 (void) get_process_comm(s->control_pid, &comm);
1919
1920 log_unit_debug_errno(UNIT(s), r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m",
1921 s->control_pid, strna(comm));
1922 }
1923 }
1924
1925 static void service_enter_start(Service *s) {
1926 ExecCommand *c;
1927 usec_t timeout;
1928 pid_t pid;
1929 int r;
1930
1931 assert(s);
1932
1933 service_unwatch_control_pid(s);
1934 service_unwatch_main_pid(s);
1935
1936 unit_warn_leftover_processes(UNIT(s));
1937
1938 if (s->type == SERVICE_FORKING) {
1939 s->control_command_id = SERVICE_EXEC_START;
1940 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1941
1942 s->main_command = NULL;
1943 } else {
1944 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1945 s->control_command = NULL;
1946
1947 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1948 }
1949
1950 if (!c) {
1951 if (s->type != SERVICE_ONESHOT) {
1952 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1953 * happen if the configuration changes at runtime. In this case, let's enter a failure
1954 * state. */
1955 log_unit_error(UNIT(s), "There's no 'start' task anymore we could start: %m");
1956 r = -ENXIO;
1957 goto fail;
1958 }
1959
1960 service_enter_start_post(s);
1961 return;
1962 }
1963
1964 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
1965 /* For simple + idle this is the main process. We don't apply any timeout here, but
1966 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1967 timeout = USEC_INFINITY;
1968 else
1969 timeout = s->timeout_start_usec;
1970
1971 r = service_spawn(s,
1972 c,
1973 timeout,
1974 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
1975 &pid);
1976 if (r < 0)
1977 goto fail;
1978
1979 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE)) {
1980 /* For simple services we immediately start
1981 * the START_POST binaries. */
1982
1983 service_set_main_pid(s, pid);
1984 service_enter_start_post(s);
1985
1986 } else if (s->type == SERVICE_FORKING) {
1987
1988 /* For forking services we wait until the start
1989 * process exited. */
1990
1991 s->control_pid = pid;
1992 service_set_state(s, SERVICE_START);
1993
1994 } else if (IN_SET(s->type, SERVICE_ONESHOT, SERVICE_DBUS, SERVICE_NOTIFY)) {
1995
1996 /* For oneshot services we wait until the start
1997 * process exited, too, but it is our main process. */
1998
1999 /* For D-Bus services we know the main pid right away,
2000 * but wait for the bus name to appear on the
2001 * bus. Notify services are similar. */
2002
2003 service_set_main_pid(s, pid);
2004 service_set_state(s, SERVICE_START);
2005 } else
2006 assert_not_reached("Unknown service type");
2007
2008 return;
2009
2010 fail:
2011 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start' task: %m");
2012 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2013 }
2014
2015 static void service_enter_start_pre(Service *s) {
2016 int r;
2017
2018 assert(s);
2019
2020 service_unwatch_control_pid(s);
2021
2022 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2023 if (s->control_command) {
2024
2025 unit_warn_leftover_processes(UNIT(s));
2026
2027 s->control_command_id = SERVICE_EXEC_START_PRE;
2028
2029 r = service_spawn(s,
2030 s->control_command,
2031 s->timeout_start_usec,
2032 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_APPLY_TTY_STDIN,
2033 &s->control_pid);
2034 if (r < 0)
2035 goto fail;
2036
2037 service_set_state(s, SERVICE_START_PRE);
2038 } else
2039 service_enter_start(s);
2040
2041 return;
2042
2043 fail:
2044 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2045 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2046 }
2047
2048 static void service_enter_restart(Service *s) {
2049 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2050 int r;
2051
2052 assert(s);
2053
2054 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2055 /* Don't restart things if we are going down anyway */
2056 log_unit_info(UNIT(s), "Stop job pending for unit, delaying automatic restart.");
2057
2058 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
2059 if (r < 0)
2060 goto fail;
2061
2062 return;
2063 }
2064
2065 /* Any units that are bound to this service must also be
2066 * restarted. We use JOB_RESTART (instead of the more obvious
2067 * JOB_START) here so that those dependency jobs will be added
2068 * as well. */
2069 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, &error, NULL);
2070 if (r < 0)
2071 goto fail;
2072
2073 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2074 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2075 * explicitly however via the usual "systemctl reset-failure" logic. */
2076 s->n_restarts ++;
2077 s->flush_n_restarts = false;
2078
2079 log_struct(LOG_INFO,
2080 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR,
2081 LOG_UNIT_ID(UNIT(s)),
2082 LOG_UNIT_INVOCATION_ID(UNIT(s)),
2083 LOG_UNIT_MESSAGE(UNIT(s), "Scheduled restart job, restart counter is at %u.", s->n_restarts),
2084 "N_RESTARTS=%u", s->n_restarts,
2085 NULL);
2086
2087 /* Notify clients about changed restart counter */
2088 unit_add_to_dbus_queue(UNIT(s));
2089
2090 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2091 * it will be canceled as part of the service_stop() call that
2092 * is executed as part of JOB_RESTART. */
2093
2094 return;
2095
2096 fail:
2097 log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, -r));
2098 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2099 }
2100
2101 static void service_enter_reload_by_notify(Service *s) {
2102 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2103 int r;
2104
2105 assert(s);
2106
2107 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_start_usec));
2108 service_set_state(s, SERVICE_RELOAD);
2109
2110 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2111 r = manager_propagate_reload(UNIT(s)->manager, UNIT(s), JOB_FAIL, &error);
2112 if (r < 0)
2113 log_unit_warning(UNIT(s), "Failed to schedule propagation of reload: %s", bus_error_message(&error, -r));
2114 }
2115
2116 static void service_enter_reload(Service *s) {
2117 int r;
2118
2119 assert(s);
2120
2121 service_unwatch_control_pid(s);
2122 s->reload_result = SERVICE_SUCCESS;
2123
2124 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2125 if (s->control_command) {
2126 s->control_command_id = SERVICE_EXEC_RELOAD;
2127
2128 r = service_spawn(s,
2129 s->control_command,
2130 s->timeout_start_usec,
2131 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL,
2132 &s->control_pid);
2133 if (r < 0)
2134 goto fail;
2135
2136 service_set_state(s, SERVICE_RELOAD);
2137 } else
2138 service_enter_running(s, SERVICE_SUCCESS);
2139
2140 return;
2141
2142 fail:
2143 log_unit_warning_errno(UNIT(s), r, "Failed to run 'reload' task: %m");
2144 s->reload_result = SERVICE_FAILURE_RESOURCES;
2145 service_enter_running(s, SERVICE_SUCCESS);
2146 }
2147
2148 static void service_run_next_control(Service *s) {
2149 usec_t timeout;
2150 int r;
2151
2152 assert(s);
2153 assert(s->control_command);
2154 assert(s->control_command->command_next);
2155
2156 assert(s->control_command_id != SERVICE_EXEC_START);
2157
2158 s->control_command = s->control_command->command_next;
2159 service_unwatch_control_pid(s);
2160
2161 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
2162 timeout = s->timeout_start_usec;
2163 else
2164 timeout = s->timeout_stop_usec;
2165
2166 r = service_spawn(s,
2167 s->control_command,
2168 timeout,
2169 EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|
2170 (IN_SET(s->control_command_id, SERVICE_EXEC_START_PRE, SERVICE_EXEC_STOP_POST) ? EXEC_APPLY_TTY_STDIN : 0)|
2171 (IN_SET(s->control_command_id, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST) ? EXEC_SETENV_RESULT : 0),
2172 &s->control_pid);
2173 if (r < 0)
2174 goto fail;
2175
2176 return;
2177
2178 fail:
2179 log_unit_warning_errno(UNIT(s), r, "Failed to run next control task: %m");
2180
2181 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START_POST, SERVICE_STOP))
2182 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2183 else if (s->state == SERVICE_STOP_POST)
2184 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2185 else if (s->state == SERVICE_RELOAD) {
2186 s->reload_result = SERVICE_FAILURE_RESOURCES;
2187 service_enter_running(s, SERVICE_SUCCESS);
2188 } else
2189 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2190 }
2191
2192 static void service_run_next_main(Service *s) {
2193 pid_t pid;
2194 int r;
2195
2196 assert(s);
2197 assert(s->main_command);
2198 assert(s->main_command->command_next);
2199 assert(s->type == SERVICE_ONESHOT);
2200
2201 s->main_command = s->main_command->command_next;
2202 service_unwatch_main_pid(s);
2203
2204 r = service_spawn(s,
2205 s->main_command,
2206 s->timeout_start_usec,
2207 EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2208 &pid);
2209 if (r < 0)
2210 goto fail;
2211
2212 service_set_main_pid(s, pid);
2213
2214 return;
2215
2216 fail:
2217 log_unit_warning_errno(UNIT(s), r, "Failed to run next main task: %m");
2218 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2219 }
2220
2221 static int service_start(Unit *u) {
2222 Service *s = SERVICE(u);
2223 int r;
2224
2225 assert(s);
2226
2227 /* We cannot fulfill this request right now, try again later
2228 * please! */
2229 if (IN_SET(s->state,
2230 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2231 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2232 return -EAGAIN;
2233
2234 /* Already on it! */
2235 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST))
2236 return 0;
2237
2238 /* A service that will be restarted must be stopped first to
2239 * trigger BindsTo and/or OnFailure dependencies. If a user
2240 * does not want to wait for the holdoff time to elapse, the
2241 * service should be manually restarted, not started. We
2242 * simply return EAGAIN here, so that any start jobs stay
2243 * queued, and assume that the auto restart timer will
2244 * eventually trigger the restart. */
2245 if (s->state == SERVICE_AUTO_RESTART)
2246 return -EAGAIN;
2247
2248 assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED));
2249
2250 /* Make sure we don't enter a busy loop of some kind. */
2251 r = unit_start_limit_test(u);
2252 if (r < 0) {
2253 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT_HIT, false);
2254 return r;
2255 }
2256
2257 r = unit_acquire_invocation_id(u);
2258 if (r < 0)
2259 return r;
2260
2261 s->result = SERVICE_SUCCESS;
2262 s->reload_result = SERVICE_SUCCESS;
2263 s->main_pid_known = false;
2264 s->main_pid_alien = false;
2265 s->forbid_restart = false;
2266
2267 u->reset_accounting = true;
2268
2269 s->status_text = mfree(s->status_text);
2270 s->status_errno = 0;
2271
2272 s->notify_state = NOTIFY_UNKNOWN;
2273
2274 s->watchdog_override_enable = false;
2275 s->watchdog_override_usec = 0;
2276
2277 /* This is not an automatic restart? Flush the restart counter then */
2278 if (s->flush_n_restarts) {
2279 s->n_restarts = 0;
2280 s->flush_n_restarts = false;
2281 }
2282
2283 service_enter_start_pre(s);
2284 return 1;
2285 }
2286
2287 static int service_stop(Unit *u) {
2288 Service *s = SERVICE(u);
2289
2290 assert(s);
2291
2292 /* Don't create restart jobs from manual stops. */
2293 s->forbid_restart = true;
2294
2295 /* Already on it */
2296 if (IN_SET(s->state,
2297 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2298 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2299 return 0;
2300
2301 /* A restart will be scheduled or is in progress. */
2302 if (s->state == SERVICE_AUTO_RESTART) {
2303 service_set_state(s, SERVICE_DEAD);
2304 return 0;
2305 }
2306
2307 /* If there's already something running we go directly into
2308 * kill mode. */
2309 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD)) {
2310 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2311 return 0;
2312 }
2313
2314 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2315
2316 service_enter_stop(s, SERVICE_SUCCESS);
2317 return 1;
2318 }
2319
2320 static int service_reload(Unit *u) {
2321 Service *s = SERVICE(u);
2322
2323 assert(s);
2324
2325 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2326
2327 service_enter_reload(s);
2328 return 1;
2329 }
2330
2331 _pure_ static bool service_can_reload(Unit *u) {
2332 Service *s = SERVICE(u);
2333
2334 assert(s);
2335
2336 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2337 }
2338
2339 static unsigned service_exec_command_index(Unit *u, ServiceExecCommand id, ExecCommand *current) {
2340 Service *s = SERVICE(u);
2341 unsigned idx = 0;
2342 ExecCommand *first, *c;
2343
2344 assert(s);
2345
2346 first = s->exec_command[id];
2347
2348 /* Figure out where we are in the list by walking back to the beginning */
2349 for (c = current; c != first; c = c->command_prev)
2350 idx++;
2351
2352 return idx;
2353 }
2354
2355 static int service_serialize_exec_command(Unit *u, FILE *f, ExecCommand *command) {
2356 Service *s = SERVICE(u);
2357 ServiceExecCommand id;
2358 unsigned idx;
2359 const char *type;
2360 char **arg;
2361 _cleanup_free_ char *args = NULL, *p = NULL;
2362 size_t allocated = 0, length = 0;
2363
2364 assert(s);
2365 assert(f);
2366
2367 if (!command)
2368 return 0;
2369
2370 if (command == s->control_command) {
2371 type = "control";
2372 id = s->control_command_id;
2373 } else {
2374 type = "main";
2375 id = SERVICE_EXEC_START;
2376 }
2377
2378 idx = service_exec_command_index(u, id, command);
2379
2380 STRV_FOREACH(arg, command->argv) {
2381 size_t n;
2382 _cleanup_free_ char *e = NULL;
2383
2384 e = xescape(*arg, WHITESPACE);
2385 if (!e)
2386 return -ENOMEM;
2387
2388 n = strlen(e);
2389 if (!GREEDY_REALLOC(args, allocated, length + 1 + n + 1))
2390 return -ENOMEM;
2391
2392 if (length > 0)
2393 args[length++] = ' ';
2394
2395 memcpy(args + length, e, n);
2396 length += n;
2397 }
2398
2399 if (!GREEDY_REALLOC(args, allocated, length + 1))
2400 return -ENOMEM;
2401 args[length++] = 0;
2402
2403 p = xescape(command->path, WHITESPACE);
2404 if (!p)
2405 return -ENOMEM;
2406
2407 fprintf(f, "%s-command=%s %u %s %s\n", type, service_exec_command_to_string(id), idx, p, args);
2408
2409 return 0;
2410 }
2411
2412 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2413 Service *s = SERVICE(u);
2414 ServiceFDStore *fs;
2415 int r;
2416
2417 assert(u);
2418 assert(f);
2419 assert(fds);
2420
2421 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2422 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2423 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2424
2425 if (s->control_pid > 0)
2426 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
2427
2428 if (s->main_pid_known && s->main_pid > 0)
2429 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2430
2431 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2432 unit_serialize_item(u, f, "bus-name-good", yes_no(s->bus_name_good));
2433 unit_serialize_item(u, f, "bus-name-owner", s->bus_name_owner);
2434
2435 unit_serialize_item_format(u, f, "n-restarts", "%u", s->n_restarts);
2436 unit_serialize_item(u, f, "flush-n-restarts", yes_no(s->flush_n_restarts));
2437
2438 r = unit_serialize_item_escaped(u, f, "status-text", s->status_text);
2439 if (r < 0)
2440 return r;
2441
2442 service_serialize_exec_command(u, f, s->control_command);
2443 service_serialize_exec_command(u, f, s->main_command);
2444
2445 r = unit_serialize_item_fd(u, f, fds, "stdin-fd", s->stdin_fd);
2446 if (r < 0)
2447 return r;
2448 r = unit_serialize_item_fd(u, f, fds, "stdout-fd", s->stdout_fd);
2449 if (r < 0)
2450 return r;
2451 r = unit_serialize_item_fd(u, f, fds, "stderr-fd", s->stderr_fd);
2452 if (r < 0)
2453 return r;
2454
2455 if (UNIT_ISSET(s->accept_socket)) {
2456 r = unit_serialize_item(u, f, "accept-socket", UNIT_DEREF(s->accept_socket)->id);
2457 if (r < 0)
2458 return r;
2459 }
2460
2461 r = unit_serialize_item_fd(u, f, fds, "socket-fd", s->socket_fd);
2462 if (r < 0)
2463 return r;
2464
2465 LIST_FOREACH(fd_store, fs, s->fd_store) {
2466 _cleanup_free_ char *c = NULL;
2467 int copy;
2468
2469 copy = fdset_put_dup(fds, fs->fd);
2470 if (copy < 0)
2471 return copy;
2472
2473 c = cescape(fs->fdname);
2474
2475 unit_serialize_item_format(u, f, "fd-store-fd", "%i %s", copy, strempty(c));
2476 }
2477
2478 if (s->main_exec_status.pid > 0) {
2479 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
2480 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2481 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2482
2483 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2484 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2485 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2486 }
2487 }
2488
2489 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2490
2491 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2492
2493 if (s->watchdog_override_enable)
2494 unit_serialize_item_format(u, f, "watchdog-override-usec", USEC_FMT, s->watchdog_override_usec);
2495
2496 return 0;
2497 }
2498
2499 static int service_deserialize_exec_command(Unit *u, const char *key, const char *value) {
2500 Service *s = SERVICE(u);
2501 int r;
2502 unsigned idx = 0, i;
2503 bool control, found = false;
2504 ServiceExecCommand id = _SERVICE_EXEC_COMMAND_INVALID;
2505 ExecCommand *command = NULL;
2506 _cleanup_free_ char *path = NULL;
2507 _cleanup_strv_free_ char **argv = NULL;
2508
2509 enum ExecCommandState {
2510 STATE_EXEC_COMMAND_TYPE,
2511 STATE_EXEC_COMMAND_INDEX,
2512 STATE_EXEC_COMMAND_PATH,
2513 STATE_EXEC_COMMAND_ARGS,
2514 _STATE_EXEC_COMMAND_MAX,
2515 _STATE_EXEC_COMMAND_INVALID = -1,
2516 } state;
2517
2518 assert(s);
2519 assert(key);
2520 assert(value);
2521
2522 control = streq(key, "control-command");
2523
2524 state = STATE_EXEC_COMMAND_TYPE;
2525
2526 for (;;) {
2527 _cleanup_free_ char *arg = NULL;
2528
2529 r = extract_first_word(&value, &arg, NULL, EXTRACT_CUNESCAPE);
2530 if (r == 0)
2531 break;
2532 else if (r < 0)
2533 return r;
2534
2535 switch (state) {
2536 case STATE_EXEC_COMMAND_TYPE:
2537 id = service_exec_command_from_string(arg);
2538 if (id < 0)
2539 return -EINVAL;
2540
2541 state = STATE_EXEC_COMMAND_INDEX;
2542 break;
2543 case STATE_EXEC_COMMAND_INDEX:
2544 r = safe_atou(arg, &idx);
2545 if (r < 0)
2546 return -EINVAL;
2547
2548 state = STATE_EXEC_COMMAND_PATH;
2549 break;
2550 case STATE_EXEC_COMMAND_PATH:
2551 path = arg;
2552 arg = NULL;
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, 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_check_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_check_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 true;
2847
2848 return false;
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 log_unit_info(UNIT(s),
3398 s->restart_usec > 0 ?
3399 "Service hold-off time over, scheduling restart." :
3400 "Service has no hold-off time, scheduling restart.");
3401 service_enter_restart(s);
3402 break;
3403
3404 default:
3405 assert_not_reached("Timeout at wrong time.");
3406 }
3407
3408 return 0;
3409 }
3410
3411 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3412 Service *s = SERVICE(userdata);
3413 char t[FORMAT_TIMESPAN_MAX];
3414 usec_t watchdog_usec;
3415
3416 assert(s);
3417 assert(source == s->watchdog_event_source);
3418
3419 watchdog_usec = service_get_watchdog_usec(s);
3420
3421 if (UNIT(s)->manager->service_watchdogs) {
3422 log_unit_error(UNIT(s), "Watchdog timeout (limit %s)!",
3423 format_timespan(t, sizeof(t), watchdog_usec, 1));
3424
3425 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
3426 } else
3427 log_unit_warning(UNIT(s), "Watchdog disabled! Ignoring watchdog timeout (limit %s)!",
3428 format_timespan(t, sizeof(t), watchdog_usec, 1));
3429
3430 return 0;
3431 }
3432
3433 static bool service_notify_message_authorized(Service *s, pid_t pid, char **tags, FDSet *fds) {
3434 assert(s);
3435
3436 if (s->notify_access == NOTIFY_NONE) {
3437 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception is disabled.", pid);
3438 return false;
3439 }
3440
3441 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3442 if (s->main_pid != 0)
3443 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);
3444 else
3445 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);
3446
3447 return false;
3448 }
3449
3450 if (s->notify_access == NOTIFY_EXEC && pid != s->main_pid && pid != s->control_pid) {
3451 if (s->main_pid != 0 && s->control_pid != 0)
3452 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,
3453 pid, s->main_pid, s->control_pid);
3454 else if (s->main_pid != 0)
3455 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);
3456 else if (s->control_pid != 0)
3457 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);
3458 else
3459 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);
3460
3461 return false;
3462 }
3463
3464 return true;
3465 }
3466
3467 static void service_notify_message(
3468 Unit *u,
3469 const struct ucred *ucred,
3470 char **tags,
3471 FDSet *fds) {
3472
3473 Service *s = SERVICE(u);
3474 bool notify_dbus = false;
3475 const char *e;
3476 char **i;
3477 int r;
3478
3479 assert(u);
3480 assert(ucred);
3481
3482 if (!service_notify_message_authorized(SERVICE(u), ucred->pid, tags, fds))
3483 return;
3484
3485 if (DEBUG_LOGGING) {
3486 _cleanup_free_ char *cc = NULL;
3487
3488 cc = strv_join(tags, ", ");
3489 log_unit_debug(u, "Got notification message from PID "PID_FMT" (%s)", ucred->pid, isempty(cc) ? "n/a" : cc);
3490 }
3491
3492 /* Interpret MAINPID= */
3493 e = strv_find_startswith(tags, "MAINPID=");
3494 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
3495 pid_t new_main_pid;
3496
3497 if (parse_pid(e, &new_main_pid) < 0)
3498 log_unit_warning(u, "Failed to parse MAINPID= field in notification message, ignoring: %s", e);
3499 else if (!s->main_pid_known || new_main_pid != s->main_pid) {
3500
3501 r = service_is_suitable_main_pid(s, new_main_pid, LOG_WARNING);
3502 if (r == 0) {
3503 /* The new main PID is a bit suspicous, which is OK if the sender is privileged. */
3504
3505 if (ucred->uid == 0) {
3506 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);
3507 r = 1;
3508 } else
3509 log_unit_debug(u, "New main PID "PID_FMT" does not belong to service, refusing.", new_main_pid);
3510 }
3511 if (r > 0) {
3512 service_set_main_pid(s, new_main_pid);
3513 unit_watch_pid(UNIT(s), new_main_pid);
3514 notify_dbus = true;
3515 }
3516 }
3517 }
3518
3519 /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3520 STRV_FOREACH_BACKWARDS(i, tags) {
3521
3522 if (streq(*i, "READY=1")) {
3523 s->notify_state = NOTIFY_READY;
3524
3525 /* Type=notify services inform us about completed
3526 * initialization with READY=1 */
3527 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
3528 service_enter_start_post(s);
3529
3530 /* Sending READY=1 while we are reloading informs us
3531 * that the reloading is complete */
3532 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
3533 service_enter_running(s, SERVICE_SUCCESS);
3534
3535 notify_dbus = true;
3536 break;
3537
3538 } else if (streq(*i, "RELOADING=1")) {
3539 s->notify_state = NOTIFY_RELOADING;
3540
3541 if (s->state == SERVICE_RUNNING)
3542 service_enter_reload_by_notify(s);
3543
3544 notify_dbus = true;
3545 break;
3546
3547 } else if (streq(*i, "STOPPING=1")) {
3548 s->notify_state = NOTIFY_STOPPING;
3549
3550 if (s->state == SERVICE_RUNNING)
3551 service_enter_stop_by_notify(s);
3552
3553 notify_dbus = true;
3554 break;
3555 }
3556 }
3557
3558 /* Interpret STATUS= */
3559 e = strv_find_startswith(tags, "STATUS=");
3560 if (e) {
3561 _cleanup_free_ char *t = NULL;
3562
3563 if (!isempty(e)) {
3564 if (!utf8_is_valid(e))
3565 log_unit_warning(u, "Status message in notification message is not UTF-8 clean.");
3566 else {
3567 t = strdup(e);
3568 if (!t)
3569 log_oom();
3570 }
3571 }
3572
3573 if (!streq_ptr(s->status_text, t)) {
3574 free_and_replace(s->status_text, t);
3575 notify_dbus = true;
3576 }
3577 }
3578
3579 /* Interpret ERRNO= */
3580 e = strv_find_startswith(tags, "ERRNO=");
3581 if (e) {
3582 int status_errno;
3583
3584 status_errno = parse_errno(e);
3585 if (status_errno < 0)
3586 log_unit_warning_errno(u, status_errno,
3587 "Failed to parse ERRNO= field in notification message: %s", e);
3588 else if (s->status_errno != status_errno) {
3589 s->status_errno = status_errno;
3590 notify_dbus = true;
3591 }
3592 }
3593
3594 /* Interpret EXTEND_TIMEOUT= */
3595 e = strv_find_startswith(tags, "EXTEND_TIMEOUT_USEC=");
3596 if (e) {
3597 usec_t extend_timeout_usec;
3598 if (safe_atou64(e, &extend_timeout_usec) < 0)
3599 log_unit_warning(u, "Failed to parse EXTEND_TIMEOUT_USEC=%s", e);
3600 else
3601 service_extend_timeout(s, extend_timeout_usec);
3602 }
3603
3604 /* Interpret WATCHDOG= */
3605 if (strv_find(tags, "WATCHDOG=1"))
3606 service_reset_watchdog(s);
3607
3608 e = strv_find_startswith(tags, "WATCHDOG_USEC=");
3609 if (e) {
3610 usec_t watchdog_override_usec;
3611 if (safe_atou64(e, &watchdog_override_usec) < 0)
3612 log_unit_warning(u, "Failed to parse WATCHDOG_USEC=%s", e);
3613 else
3614 service_reset_watchdog_timeout(s, watchdog_override_usec);
3615 }
3616
3617 /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
3618 * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
3619 * fds, but optional when pushing in new fds, for compatibility reasons. */
3620 if (strv_find(tags, "FDSTOREREMOVE=1")) {
3621 const char *name;
3622
3623 name = strv_find_startswith(tags, "FDNAME=");
3624 if (!name || !fdname_is_valid(name))
3625 log_unit_warning(u, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
3626 else
3627 service_remove_fd_store(s, name);
3628
3629 } else if (strv_find(tags, "FDSTORE=1")) {
3630 const char *name;
3631
3632 name = strv_find_startswith(tags, "FDNAME=");
3633 if (name && !fdname_is_valid(name)) {
3634 log_unit_warning(u, "Passed FDNAME= name is invalid, ignoring.");
3635 name = NULL;
3636 }
3637
3638 (void) service_add_fd_store_set(s, fds, name);
3639 }
3640
3641 /* Notify clients about changed status or main pid */
3642 if (notify_dbus)
3643 unit_add_to_dbus_queue(u);
3644 }
3645
3646 static int service_get_timeout(Unit *u, usec_t *timeout) {
3647 Service *s = SERVICE(u);
3648 uint64_t t;
3649 int r;
3650
3651 if (!s->timer_event_source)
3652 return 0;
3653
3654 r = sd_event_source_get_time(s->timer_event_source, &t);
3655 if (r < 0)
3656 return r;
3657 if (t == USEC_INFINITY)
3658 return 0;
3659
3660 *timeout = t;
3661 return 1;
3662 }
3663
3664 static void service_bus_name_owner_change(
3665 Unit *u,
3666 const char *name,
3667 const char *old_owner,
3668 const char *new_owner) {
3669
3670 Service *s = SERVICE(u);
3671 int r;
3672
3673 assert(s);
3674 assert(name);
3675
3676 assert(streq(s->bus_name, name));
3677 assert(old_owner || new_owner);
3678
3679 if (old_owner && new_owner)
3680 log_unit_debug(u, "D-Bus name %s changed owner from %s to %s", name, old_owner, new_owner);
3681 else if (old_owner)
3682 log_unit_debug(u, "D-Bus name %s no longer registered by %s", name, old_owner);
3683 else
3684 log_unit_debug(u, "D-Bus name %s now registered by %s", name, new_owner);
3685
3686 s->bus_name_good = !!new_owner;
3687
3688 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3689 r = free_and_strdup(&s->bus_name_owner, new_owner);
3690 if (r < 0) {
3691 log_unit_error_errno(u, r, "Unable to set new bus name owner %s: %m", new_owner);
3692 return;
3693 }
3694
3695 if (s->type == SERVICE_DBUS) {
3696
3697 /* service_enter_running() will figure out what to
3698 * do */
3699 if (s->state == SERVICE_RUNNING)
3700 service_enter_running(s, SERVICE_SUCCESS);
3701 else if (s->state == SERVICE_START && new_owner)
3702 service_enter_start_post(s);
3703
3704 } else if (new_owner &&
3705 s->main_pid <= 0 &&
3706 IN_SET(s->state,
3707 SERVICE_START,
3708 SERVICE_START_POST,
3709 SERVICE_RUNNING,
3710 SERVICE_RELOAD)) {
3711
3712 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
3713 pid_t pid;
3714
3715 /* Try to acquire PID from bus service */
3716
3717 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3718 if (r >= 0)
3719 r = sd_bus_creds_get_pid(creds, &pid);
3720 if (r >= 0) {
3721 log_unit_debug(u, "D-Bus name %s is now owned by process " PID_FMT, name, pid);
3722
3723 service_set_main_pid(s, pid);
3724 unit_watch_pid(UNIT(s), pid);
3725 }
3726 }
3727 }
3728
3729 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
3730 _cleanup_free_ char *peer = NULL;
3731 int r;
3732
3733 assert(s);
3734 assert(fd >= 0);
3735
3736 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3737 * to be configured. We take ownership of the passed fd on success. */
3738
3739 if (UNIT(s)->load_state != UNIT_LOADED)
3740 return -EINVAL;
3741
3742 if (s->socket_fd >= 0)
3743 return -EBUSY;
3744
3745 if (s->state != SERVICE_DEAD)
3746 return -EAGAIN;
3747
3748 if (getpeername_pretty(fd, true, &peer) >= 0) {
3749
3750 if (UNIT(s)->description) {
3751 _cleanup_free_ char *a;
3752
3753 a = strjoin(UNIT(s)->description, " (", peer, ")");
3754 if (!a)
3755 return -ENOMEM;
3756
3757 r = unit_set_description(UNIT(s), a);
3758 } else
3759 r = unit_set_description(UNIT(s), peer);
3760
3761 if (r < 0)
3762 return r;
3763 }
3764
3765 r = unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false, UNIT_DEPENDENCY_IMPLICIT);
3766 if (r < 0)
3767 return r;
3768
3769 s->socket_fd = fd;
3770 s->socket_fd_selinux_context_net = selinux_context_net;
3771
3772 unit_ref_set(&s->accept_socket, UNIT(sock));
3773 return 0;
3774 }
3775
3776 static void service_reset_failed(Unit *u) {
3777 Service *s = SERVICE(u);
3778
3779 assert(s);
3780
3781 if (s->state == SERVICE_FAILED)
3782 service_set_state(s, SERVICE_DEAD);
3783
3784 s->result = SERVICE_SUCCESS;
3785 s->reload_result = SERVICE_SUCCESS;
3786 s->n_restarts = 0;
3787 s->flush_n_restarts = false;
3788 }
3789
3790 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3791 Service *s = SERVICE(u);
3792
3793 assert(s);
3794
3795 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3796 }
3797
3798 static int service_main_pid(Unit *u) {
3799 Service *s = SERVICE(u);
3800
3801 assert(s);
3802
3803 return s->main_pid;
3804 }
3805
3806 static int service_control_pid(Unit *u) {
3807 Service *s = SERVICE(u);
3808
3809 assert(s);
3810
3811 return s->control_pid;
3812 }
3813
3814 static bool service_needs_console(Unit *u) {
3815 Service *s = SERVICE(u);
3816
3817 assert(s);
3818
3819 /* We provide our own implementation of this here, instead of relying of the generic implementation
3820 * unit_needs_console() provides, since we want to return false if we are in SERVICE_EXITED state. */
3821
3822 if (!exec_context_may_touch_console(&s->exec_context))
3823 return false;
3824
3825 return IN_SET(s->state,
3826 SERVICE_START_PRE,
3827 SERVICE_START,
3828 SERVICE_START_POST,
3829 SERVICE_RUNNING,
3830 SERVICE_RELOAD,
3831 SERVICE_STOP,
3832 SERVICE_STOP_SIGABRT,
3833 SERVICE_STOP_SIGTERM,
3834 SERVICE_STOP_SIGKILL,
3835 SERVICE_STOP_POST,
3836 SERVICE_FINAL_SIGTERM,
3837 SERVICE_FINAL_SIGKILL);
3838 }
3839
3840 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3841 [SERVICE_RESTART_NO] = "no",
3842 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3843 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3844 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
3845 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3846 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3847 [SERVICE_RESTART_ALWAYS] = "always",
3848 };
3849
3850 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3851
3852 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3853 [SERVICE_SIMPLE] = "simple",
3854 [SERVICE_FORKING] = "forking",
3855 [SERVICE_ONESHOT] = "oneshot",
3856 [SERVICE_DBUS] = "dbus",
3857 [SERVICE_NOTIFY] = "notify",
3858 [SERVICE_IDLE] = "idle"
3859 };
3860
3861 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3862
3863 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3864 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3865 [SERVICE_EXEC_START] = "ExecStart",
3866 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3867 [SERVICE_EXEC_RELOAD] = "ExecReload",
3868 [SERVICE_EXEC_STOP] = "ExecStop",
3869 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3870 };
3871
3872 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3873
3874 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3875 [NOTIFY_UNKNOWN] = "unknown",
3876 [NOTIFY_READY] = "ready",
3877 [NOTIFY_RELOADING] = "reloading",
3878 [NOTIFY_STOPPING] = "stopping",
3879 };
3880
3881 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3882
3883 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3884 [SERVICE_SUCCESS] = "success",
3885 [SERVICE_FAILURE_RESOURCES] = "resources",
3886 [SERVICE_FAILURE_PROTOCOL] = "protocol",
3887 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3888 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3889 [SERVICE_FAILURE_SIGNAL] = "signal",
3890 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3891 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3892 [SERVICE_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
3893 };
3894
3895 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3896
3897 const UnitVTable service_vtable = {
3898 .object_size = sizeof(Service),
3899 .exec_context_offset = offsetof(Service, exec_context),
3900 .cgroup_context_offset = offsetof(Service, cgroup_context),
3901 .kill_context_offset = offsetof(Service, kill_context),
3902 .exec_runtime_offset = offsetof(Service, exec_runtime),
3903 .dynamic_creds_offset = offsetof(Service, dynamic_creds),
3904
3905 .sections =
3906 "Unit\0"
3907 "Service\0"
3908 "Install\0",
3909 .private_section = "Service",
3910
3911 .can_transient = true,
3912 .can_delegate = true,
3913
3914 .init = service_init,
3915 .done = service_done,
3916 .load = service_load,
3917 .release_resources = service_release_resources,
3918
3919 .coldplug = service_coldplug,
3920
3921 .dump = service_dump,
3922
3923 .start = service_start,
3924 .stop = service_stop,
3925 .reload = service_reload,
3926
3927 .can_reload = service_can_reload,
3928
3929 .kill = service_kill,
3930
3931 .serialize = service_serialize,
3932 .deserialize_item = service_deserialize_item,
3933
3934 .active_state = service_active_state,
3935 .sub_state_to_string = service_sub_state_to_string,
3936
3937 .will_restart = service_will_restart,
3938
3939 .check_gc = service_check_gc,
3940
3941 .sigchld_event = service_sigchld_event,
3942
3943 .reset_failed = service_reset_failed,
3944
3945 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3946 .notify_message = service_notify_message,
3947
3948 .main_pid = service_main_pid,
3949 .control_pid = service_control_pid,
3950
3951 .bus_name_owner_change = service_bus_name_owner_change,
3952
3953 .bus_vtable = bus_service_vtable,
3954 .bus_set_property = bus_service_set_property,
3955 .bus_commit_properties = bus_service_commit_properties,
3956
3957 .get_timeout = service_get_timeout,
3958 .needs_console = service_needs_console,
3959
3960 .status_message_formats = {
3961 .starting_stopping = {
3962 [0] = "Starting %s...",
3963 [1] = "Stopping %s...",
3964 },
3965 .finished_start_job = {
3966 [JOB_DONE] = "Started %s.",
3967 [JOB_FAILED] = "Failed to start %s.",
3968 },
3969 .finished_stop_job = {
3970 [JOB_DONE] = "Stopped %s.",
3971 [JOB_FAILED] = "Stopped (with error) %s.",
3972 },
3973 },
3974 };
Unnamed repository; edit this file 'description' to name the repository.