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