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