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