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