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