]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/service.c
projects / thirdparty / systemd.git / blob
? search:


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