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