]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/service.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
shared: add process-util.[ch]
[thirdparty/systemd.git] / src / core / service.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
5cb5a6ff 2
a7334b09
LP		 3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
5430f7f2
LP		 9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
a7334b09
LP		 11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
5cb5a6ff 22#include <errno.h>
034c6ed7 23#include <signal.h>
2c4104f0 24#include <unistd.h>
5cb5a6ff 25
574634bc 26#include "async.h"
4b939747 27#include "manager.h"
87f0e418 28#include "unit.h"
5cb5a6ff
LP		 29#include "service.h"
30#include "load-fragment.h"
31#include "load-dropin.h"
034c6ed7 32#include "log.h"
2c4104f0 33#include "strv.h"
9e2f7c11 34#include "unit-name.h"
41f9172f 35#include "unit-printf.h"
4139c1b2 36#include "dbus-service.h"
514f4ef5 37#include "special.h"
9a57c629 38#include "exit-status.h"
f6a6225e 39#include "def.h"
9eb977db 40#include "path-util.h"
f6a6225e 41#include "util.h"
7f110ff9 42#include "utf8.h"
4d1a6904 43#include "env-util.h"
a5c32cff 44#include "fileio.h"
718db961
LP		 45#include "bus-error.h"
46#include "bus-util.h"
e44da745 47#include "bus-kernel.h"
6482f626 48#include "formats-util.h"
0b452006 49#include "process-util.h"
034c6ed7 50
acbb0225 51static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
87f0e418
LP		 52 [SERVICE_DEAD] = UNIT_INACTIVE,
53 [SERVICE_START_PRE] = UNIT_ACTIVATING,
54 [SERVICE_START] = UNIT_ACTIVATING,
55 [SERVICE_START_POST] = UNIT_ACTIVATING,
56 [SERVICE_RUNNING] = UNIT_ACTIVE,
80876c20 57 [SERVICE_EXITED] = UNIT_ACTIVE,
032ff4af 58 [SERVICE_RELOAD] = UNIT_RELOADING,
87f0e418 59 [SERVICE_STOP] = UNIT_DEACTIVATING,
db2cb23b 60 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
87f0e418
LP		 61 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
62 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
63 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
64 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
65 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
fdf20a31 66 [SERVICE_FAILED] = UNIT_FAILED,
6124958c 67 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
034c6ed7 68};
5cb5a6ff 69
e056b01d
LP		 70/* For Type=idle we never want to delay any other jobs, hence we
71 * consider idle jobs active as soon as we start working on them */
72static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
73 [SERVICE_DEAD] = UNIT_INACTIVE,
74 [SERVICE_START_PRE] = UNIT_ACTIVE,
75 [SERVICE_START] = UNIT_ACTIVE,
76 [SERVICE_START_POST] = UNIT_ACTIVE,
77 [SERVICE_RUNNING] = UNIT_ACTIVE,
78 [SERVICE_EXITED] = UNIT_ACTIVE,
79 [SERVICE_RELOAD] = UNIT_RELOADING,
80 [SERVICE_STOP] = UNIT_DEACTIVATING,
db2cb23b 81 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
e056b01d
LP		 82 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
83 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
84 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
85 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
86 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
87 [SERVICE_FAILED] = UNIT_FAILED,
88 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
89};
90
718db961
LP		 91static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
92static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
93static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
94
842129f5 95static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
308d72dc 96static void service_enter_reload_by_notify(Service *s);
842129f5 97
a16e1123
LP		 98static void service_init(Unit *u) {
99 Service *s = SERVICE(u);
100
101 assert(u);
ac155bb8 102 assert(u->load_state == UNIT_STUB);
a16e1123 103
1f19a534
OS		 104 s->timeout_start_usec = u->manager->default_timeout_start_usec;
105 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
106 s->restart_usec = u->manager->default_restart_usec;
0b86feac 107 s->type = _SERVICE_TYPE_INVALID;
a16e1123 108 s->socket_fd = -1;
e44da745 109 s->bus_endpoint_fd = -1;
3185a36b 110 s->guess_main_pid = true;
a16e1123 111
085afe36 112 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
a16e1123
LP		 113
114 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
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
79008bdd 141 log_unit_debug(UNIT(s)->id, "Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
718db961 142 path_spec_unwatch(s->pid_file_pathspec);
3e52541e
MS		 143 path_spec_done(s->pid_file_pathspec);
144 free(s->pid_file_pathspec);
145 s->pid_file_pathspec = NULL;
146}
147
5925dd3c 148static int service_set_main_pid(Service *s, pid_t pid) {
e55224ca
LP		 149 pid_t ppid;
150
5925dd3c
LP		 151 assert(s);
152
153 if (pid <= 1)
154 return -EINVAL;
155
156 if (pid == getpid())
157 return -EINVAL;
158
7400b9d2
LP		 159 if (s->main_pid == pid && s->main_pid_known)
160 return 0;
161
162 if (s->main_pid != pid) {
163 service_unwatch_main_pid(s);
164 exec_status_start(&s->main_exec_status, pid);
165 }
41efeaec 166
6dfa5494
LP		 167 s->main_pid = pid;
168 s->main_pid_known = true;
169
170 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
79008bdd 171 log_unit_warning(UNIT(s)->id, "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", UNIT(s)->id, pid);
6dfa5494
LP		 172 s->main_pid_alien = true;
173 } else
174 s->main_pid_alien = false;
5925dd3c
LP		 175
176 return 0;
177}
178
4f2d528d
LP		 179static void service_close_socket_fd(Service *s) {
180 assert(s);
181
574634bc 182 s->socket_fd = asynchronous_close(s->socket_fd);
4f2d528d
LP		 183}
184
6cf6bbc2
LP		 185static void service_connection_unref(Service *s) {
186 assert(s);
187
9444b1f2 188 if (!UNIT_ISSET(s->accept_socket))
6cf6bbc2
LP		 189 return;
190
57020a3a
LP		 191 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
192 unit_ref_unset(&s->accept_socket);
6cf6bbc2
LP		 193}
194
a6927d7f
MO		 195static void service_stop_watchdog(Service *s) {
196 assert(s);
197
718db961 198 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
842129f5 199 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
a6927d7f
MO		 200}
201
842129f5 202static void service_start_watchdog(Service *s) {
bb242b7b
MO		 203 int r;
204
205 assert(s);
206
842129f5 207 if (s->watchdog_usec <= 0)
bb242b7b
MO		 208 return;
209
718db961
LP		 210 if (s->watchdog_event_source) {
211 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
212 if (r < 0) {
31938a85 213 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to reset watchdog timer: %m", UNIT(s)->id);
718db961
LP		 214 return;
215 }
216
842129f5 217 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
c4ef3317 218 } else {
6a0f1f6d
LP		 219 r = sd_event_add_time(
220 UNIT(s)->manager->event,
221 &s->watchdog_event_source,
222 CLOCK_MONOTONIC,
223 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
224 service_dispatch_watchdog, s);
c4ef3317 225 if (r < 0) {
31938a85 226 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to add watchdog timer: %m", UNIT(s)->id);
c4ef3317
LP		 227 return;
228 }
229
230 /* Let's process everything else which might be a sign
231 * of living before we consider a service died. */
232 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
233 }
718db961 234
bb242b7b 235 if (r < 0)
31938a85 236 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to install watchdog timer: %m", UNIT(s)->id);
bb242b7b
MO		 237}
238
a6927d7f
MO		 239static void service_reset_watchdog(Service *s) {
240 assert(s);
241
242 dual_timestamp_get(&s->watchdog_timestamp);
842129f5 243 service_start_watchdog(s);
a6927d7f
MO		 244}
245
a354329f
LP		 246static void service_fd_store_unlink(ServiceFDStore *fs) {
247
248 if (!fs)
249 return;
250
251 if (fs->service) {
252 assert(fs->service->n_fd_store > 0);
253 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
254 fs->service->n_fd_store--;
255 }
256
257 if (fs->event_source) {
258 sd_event_source_set_enabled(fs->event_source, SD_EVENT_OFF);
259 sd_event_source_unref(fs->event_source);
260 }
261
262 safe_close(fs->fd);
263 free(fs);
264}
265
266static void service_release_resources(Unit *u) {
267 Service *s = SERVICE(u);
268
269 assert(s);
270
271 if (!s->fd_store)
272 return;
273
274 log_debug("Releasing all resources for %s", u->id);
275
276 while (s->fd_store)
277 service_fd_store_unlink(s->fd_store);
278
279 assert(s->n_fd_store == 0);
280}
281
87f0e418
LP		 282static void service_done(Unit *u) {
283 Service *s = SERVICE(u);
44d8db9e
LP		 284
285 assert(s);
286
287 free(s->pid_file);
288 s->pid_file = NULL;
289
8c47c732
LP		 290 free(s->status_text);
291 s->status_text = NULL;
292
efe6e7d3
MO		 293 free(s->reboot_arg);
294 s->reboot_arg = NULL;
295
613b411c 296 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
e537352b 297 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
44d8db9e 298 s->control_command = NULL;
867b3b7d 299 s->main_command = NULL;
44d8db9e 300
37520c1b
LP		 301 exit_status_set_free(&s->restart_prevent_status);
302 exit_status_set_free(&s->restart_force_status);
303 exit_status_set_free(&s->success_status);
96342de6 304
44d8db9e
LP		 305 /* This will leak a process, but at least no memory or any of
306 * our resources */
5e94833f
LP		 307 service_unwatch_main_pid(s);
308 service_unwatch_control_pid(s);
3e52541e 309 service_unwatch_pid_file(s);
44d8db9e 310
05e343b7 311 if (s->bus_name) {
ac155bb8 312 unit_unwatch_bus_name(u, s->bus_name);
05e343b7
LP		 313 free(s->bus_name);
314 s->bus_name = NULL;
315 }
316
e44da745 317 s->bus_endpoint_fd = safe_close(s->bus_endpoint_fd);
4f2d528d 318 service_close_socket_fd(s);
6cf6bbc2 319 service_connection_unref(s);
4f2d528d 320
57020a3a 321 unit_ref_unset(&s->accept_socket);
f976f3f6 322
bb242b7b
MO		 323 service_stop_watchdog(s);
324
718db961 325 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
a354329f
LP		 326
327 service_release_resources(u);
718db961
LP		 328}
329
2339fc93
LP		 330static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
331 ServiceFDStore *fs = userdata;
332
333 assert(e);
334 assert(fs);
335
336 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
337 service_fd_store_unlink(fs);
338 return 0;
339}
340
341static int service_add_fd_store(Service *s, int fd) {
342 ServiceFDStore *fs;
343 int r;
344
345 assert(s);
346 assert(fd >= 0);
347
348 if (s->n_fd_store >= s->n_fd_store_max)
349 return 0;
350
351 LIST_FOREACH(fd_store, fs, s->fd_store) {
352 r = same_fd(fs->fd, fd);
353 if (r < 0)
354 return r;
355 if (r > 0) {
356 /* Already included */
357 safe_close(fd);
358 return 1;
359 }
360 }
361
362 fs = new0(ServiceFDStore, 1);
363 if (!fs)
364 return -ENOMEM;
365
366 fs->fd = fd;
367 fs->service = s;
368
369 r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
370 if (r < 0) {
371 free(fs);
372 return r;
373 }
374
375 LIST_PREPEND(fd_store, s->fd_store, fs);
376 s->n_fd_store++;
377
378 return 1;
379}
380
381static int service_add_fd_store_set(Service *s, FDSet *fds) {
382 int r;
383
384 assert(s);
385
386 if (fdset_size(fds) <= 0)
387 return 0;
388
389 while (s->n_fd_store < s->n_fd_store_max) {
390 _cleanup_close_ int fd = -1;
391
392 fd = fdset_steal_first(fds);
393 if (fd < 0)
394 break;
395
396 r = service_add_fd_store(s, fd);
397 if (r < 0)
398 return log_unit_error_errno(UNIT(s)->id, r, "%s: Couldn't add fd to fd store: %m", UNIT(s)->id);
399
400 if (r > 0) {
401 log_unit_debug(UNIT(s)->id, "%s: added fd to fd store.", UNIT(s)->id);
402 fd = -1;
403 }
404 }
405
406 if (fdset_size(fds) > 0)
407 log_unit_warning(UNIT(s)->id, "%s: tried to store more fds than FDStoreMax=%u allows, closing remaining.", UNIT(s)->id, s->n_fd_store_max);
408
409 return 0;
410}
411
718db961
LP		 412static int service_arm_timer(Service *s, usec_t usec) {
413 int r;
414
415 assert(s);
416
718db961
LP		 417 if (s->timer_event_source) {
418 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
419 if (r < 0)
420 return r;
421
422 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
423 }
424
6a0f1f6d
LP		 425 return sd_event_add_time(
426 UNIT(s)->manager->event,
427 &s->timer_event_source,
428 CLOCK_MONOTONIC,
429 now(CLOCK_MONOTONIC) + usec, 0,
430 service_dispatch_timer, s);
44d8db9e
LP		 431}
432
243b1432
LP		 433static int service_verify(Service *s) {
434 assert(s);
435
1124fe6f 436 if (UNIT(s)->load_state != UNIT_LOADED)
243b1432
LP		 437 return 0;
438
96fb8242 439 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
79008bdd 440 log_unit_error(UNIT(s)->id, "%s lacks both ExecStart= and ExecStop= setting. Refusing.", UNIT(s)->id);
243b1432
LP		 441 return -EINVAL;
442 }
443
96fb8242 444 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
79008bdd 445 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
96fb8242
LP		 446 return -EINVAL;
447 }
448
449 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
79008bdd 450 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.", UNIT(s)->id);
96fb8242
LP		 451 return -EINVAL;
452 }
453
454 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
79008bdd 455 log_unit_error(UNIT(s)->id, "%s has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
6cf6bbc2
LP		 456 return -EINVAL;
457 }
458
b0693d30 459 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
79008bdd 460 log_unit_error(UNIT(s)->id, "%s has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
37520c1b
LP		 461 return -EINVAL;
462 }
463
55ebf98c 464 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
79008bdd 465 log_unit_error(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
b0693d30
MW		 466 return -EINVAL;
467 }
468
05e343b7 469 if (s->type == SERVICE_DBUS && !s->bus_name) {
79008bdd 470 log_unit_error(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
4d0e5dbd
LP		 471 return -EINVAL;
472 }
473
7e2668c6 474 if (s->bus_name && s->type != SERVICE_DBUS)
79008bdd 475 log_unit_warning(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
7e2668c6 476
ebc2259d 477 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
79008bdd 478 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
05e343b7
LP		 479 return -EINVAL;
480 }
481
243b1432
LP		 482 return 0;
483}
484
a40eb732
LP		 485static int service_add_default_dependencies(Service *s) {
486 int r;
487
488 assert(s);
489
490 /* Add a number of automatic dependencies useful for the
491 * majority of services. */
492
493 /* First, pull in base system */
8bb2d17d 494 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
fccd44ec
KS		 495 if (r < 0)
496 return r;
a40eb732
LP		 497
498 /* Second, activate normal shutdown */
8545f7ce 499 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
a40eb732
LP		 500}
501
4dfc092a
LP		 502static void service_fix_output(Service *s) {
503 assert(s);
504
505 /* If nothing has been explicitly configured, patch default
506 * output in. If input is socket/tty we avoid this however,
507 * since in that case we want output to default to the same
508 * place as we read input from. */
509
510 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
511 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
512 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 513 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
4dfc092a
LP		 514
515 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
516 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 517 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
4dfc092a
LP		 518}
519
8545f7ce
LP		 520static int service_add_extras(Service *s) {
521 int r;
522
523 assert(s);
524
525 if (s->type == _SERVICE_TYPE_INVALID) {
526 /* Figure out a type automatically */
527 if (s->bus_name)
528 s->type = SERVICE_DBUS;
529 else if (s->exec_command[SERVICE_EXEC_START])
530 s->type = SERVICE_SIMPLE;
531 else
532 s->type = SERVICE_ONESHOT;
533 }
534
535 /* Oneshot services have disabled start timeout by default */
536 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
537 s->timeout_start_usec = 0;
538
539 service_fix_output(s);
540
541 r = unit_patch_contexts(UNIT(s));
542 if (r < 0)
543 return r;
544
545 r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
546 if (r < 0)
547 return r;
548
549 r = unit_add_default_slice(UNIT(s), &s->cgroup_context);
550 if (r < 0)
551 return r;
552
553 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
554 s->notify_access = NOTIFY_MAIN;
555
556 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
557 s->notify_access = NOTIFY_MAIN;
558
559 if (s->bus_name) {
6962fd3b 560#ifdef ENABLE_KDBUS
8545f7ce
LP		 561 const char *n;
562
6962fd3b
MB		 563 n = strjoina(s->bus_name, ".busname");
564 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, n, NULL, true);
8545f7ce
LP		 565 if (r < 0)
566 return r;
6962fd3b 567#endif
8545f7ce 568
6962fd3b 569 r = unit_watch_bus_name(UNIT(s), s->bus_name);
8545f7ce
LP		 570 if (r < 0)
571 return r;
572 }
573
574 if (UNIT(s)->default_dependencies) {
575 r = service_add_default_dependencies(s);
576 if (r < 0)
577 return r;
578 }
579
580 return 0;
581}
582
e537352b 583static int service_load(Unit *u) {
e537352b 584 Service *s = SERVICE(u);
8bb2d17d 585 int r;
e537352b
LP		 586
587 assert(s);
1e2e8133 588
5cb5a6ff 589 /* Load a .service file */
c2756a68
LP		 590 r = unit_load_fragment(u);
591 if (r < 0)
5cb5a6ff
LP		 592 return r;
593
23a177ef 594 /* Still nothing found? Then let's give up */
ac155bb8 595 if (u->load_state == UNIT_STUB)
23a177ef 596 return -ENOENT;
034c6ed7 597
23a177ef 598 /* This is a new unit? Then let's add in some extras */
ac155bb8 599 if (u->load_state == UNIT_LOADED) {
c2756a68
LP		 600
601 /* We were able to load something, then let's add in
602 * the dropin directories. */
603 r = unit_load_dropin(u);
604 if (r < 0)
605 return r;
606
8545f7ce
LP		 607 /* This is a new unit? Then let's add in some
608 * extras */
609 r = service_add_extras(s);
598459ce
LP		 610 if (r < 0)
611 return r;
8e274523
LP		 612 }
613
243b1432 614 return service_verify(s);
034c6ed7
LP		 615}
616
87f0e418 617static void service_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 618 ServiceExecCommand c;
87f0e418 619 Service *s = SERVICE(u);
47be870b 620 const char *prefix2;
5cb5a6ff
LP		 621
622 assert(s);
623
4c940960 624 prefix = strempty(prefix);
63c372cb 625 prefix2 = strjoina(prefix, "\t");
44d8db9e 626
5cb5a6ff 627 fprintf(f,
81a2b7ce 628 "%sService State: %s\n"
f42806df
LP		 629 "%sResult: %s\n"
630 "%sReload Result: %s\n"
81a2b7ce 631 "%sPermissionsStartOnly: %s\n"
8e274523 632 "%sRootDirectoryStartOnly: %s\n"
02ee865a 633 "%sRemainAfterExit: %s\n"
3185a36b 634 "%sGuessMainPID: %s\n"
c952c6ec 635 "%sType: %s\n"
2cf3143a 636 "%sRestart: %s\n"
308d72dc
LP		 637 "%sNotifyAccess: %s\n"
638 "%sNotifyState: %s\n",
81a2b7ce 639 prefix, service_state_to_string(s->state),
f42806df
LP		 640 prefix, service_result_to_string(s->result),
641 prefix, service_result_to_string(s->reload_result),
81a2b7ce 642 prefix, yes_no(s->permissions_start_only),
8e274523 643 prefix, yes_no(s->root_directory_start_only),
02ee865a 644 prefix, yes_no(s->remain_after_exit),
3185a36b 645 prefix, yes_no(s->guess_main_pid),
c952c6ec 646 prefix, service_type_to_string(s->type),
2cf3143a 647 prefix, service_restart_to_string(s->restart),
308d72dc
LP		 648 prefix, notify_access_to_string(s->notify_access),
649 prefix, notify_state_to_string(s->notify_state));
5cb5a6ff 650
70123e68
LP		 651 if (s->control_pid > 0)
652 fprintf(f,
ccd06097
ZJS		 653 "%sControl PID: "PID_FMT"\n",
654 prefix, s->control_pid);
70123e68
LP		 655
656 if (s->main_pid > 0)
657 fprintf(f,
ccd06097 658 "%sMain PID: "PID_FMT"\n"
6dfa5494
LP		 659 "%sMain PID Known: %s\n"
660 "%sMain PID Alien: %s\n",
ccd06097 661 prefix, s->main_pid,
6dfa5494
LP		 662 prefix, yes_no(s->main_pid_known),
663 prefix, yes_no(s->main_pid_alien));
70123e68 664
034c6ed7
LP		 665 if (s->pid_file)
666 fprintf(f,
667 "%sPIDFile: %s\n",
668 prefix, s->pid_file);
669
05e343b7
LP		 670 if (s->bus_name)
671 fprintf(f,
672 "%sBusName: %s\n"
673 "%sBus Name Good: %s\n",
674 prefix, s->bus_name,
675 prefix, yes_no(s->bus_name_good));
676
4819ff03 677 kill_context_dump(&s->kill_context, f, prefix);
5cb5a6ff
LP		 678 exec_context_dump(&s->exec_context, f, prefix);
679
e537352b 680 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
5cb5a6ff 681
44d8db9e
LP		 682 if (!s->exec_command[c])
683 continue;
684
40d50879 685 fprintf(f, "%s-> %s:\n",
94f04347 686 prefix, service_exec_command_to_string(c));
44d8db9e
LP		 687
688 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 689 }
44d8db9e 690
8c47c732
LP		 691 if (s->status_text)
692 fprintf(f, "%sStatus Text: %s\n",
693 prefix, s->status_text);
a354329f
LP		 694
695 if (s->n_fd_store_max > 0) {
696 fprintf(f,
697 "%sFile Descriptor Store Max: %u\n"
698 "%sFile Descriptor Store Current: %u\n",
699 prefix, s->n_fd_store_max,
700 prefix, s->n_fd_store);
701 }
5cb5a6ff
LP		 702}
703
c5419d42 704static int service_load_pid_file(Service *s, bool may_warn) {
7fd1b19b 705 _cleanup_free_ char *k = NULL;
034c6ed7 706 int r;
5925dd3c 707 pid_t pid;
034c6ed7
LP		 708
709 assert(s);
710
034c6ed7 711 if (!s->pid_file)
13230d5d 712 return -ENOENT;
034c6ed7 713
117dcc57
ZJS		 714 r = read_one_line_file(s->pid_file, &k);
715 if (r < 0) {
c5419d42 716 if (may_warn)
79008bdd 717 log_unit_info(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
034c6ed7 718 return r;
5375410b 719 }
034c6ed7 720
5925dd3c 721 r = parse_pid(k, &pid);
bc41f93e
ZJS		 722 if (r < 0) {
723 if (may_warn)
31938a85 724 log_unit_info_errno(UNIT(s)->id, r, "Failed to read PID from file %s: %m", s->pid_file);
5925dd3c 725 return r;
bc41f93e 726 }
406eaf93 727
9f5650ae 728 if (!pid_is_alive(pid)) {
c5419d42 729 if (may_warn)
79008bdd 730 log_unit_info(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
e10c9985
YS		 731 return -ESRCH;
732 }
733
db01f8b3
MS		 734 if (s->main_pid_known) {
735 if (pid == s->main_pid)
736 return 0;
737
79008bdd 738 log_unit_debug(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
8bb2d17d 739
db01f8b3
MS		 740 service_unwatch_main_pid(s);
741 s->main_pid_known = false;
3a111838 742 } else
79008bdd 743 log_unit_debug(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
db01f8b3 744
117dcc57
ZJS		 745 r = service_set_main_pid(s, pid);
746 if (r < 0)
16f6025e
LP		 747 return r;
748
117dcc57 749 r = unit_watch_pid(UNIT(s), pid);
bc41f93e 750 if (r < 0) {
5925dd3c 751 /* FIXME: we need to do something here */
79008bdd 752 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
5925dd3c 753 return r;
bc41f93e 754 }
034c6ed7
LP		 755
756 return 0;
757}
758
4fbf50b3
LP		 759static int service_search_main_pid(Service *s) {
760 pid_t pid;
761 int r;
762
763 assert(s);
764
3185a36b
LP		 765 /* If we know it anyway, don't ever fallback to unreliable
766 * heuristics */
4fbf50b3
LP		 767 if (s->main_pid_known)
768 return 0;
769
3185a36b
LP		 770 if (!s->guess_main_pid)
771 return 0;
772
4fbf50b3
LP		 773 assert(s->main_pid <= 0);
774
4ad49000 775 pid = unit_search_main_pid(UNIT(s));
117dcc57 776 if (pid <= 0)
4fbf50b3
LP		 777 return -ENOENT;
778
79008bdd 779 log_unit_debug(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
117dcc57
ZJS		 780 r = service_set_main_pid(s, pid);
781 if (r < 0)
4fbf50b3
LP		 782 return r;
783
117dcc57 784 r = unit_watch_pid(UNIT(s), pid);
8bb2d17d 785 if (r < 0) {
4fbf50b3 786 /* FIXME: we need to do something here */
79008bdd 787 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
8bb2d17d
LP		 788 return r;
789 }
790
791 return 0;
4fbf50b3
LP		 792}
793
034c6ed7
LP		 794static void service_set_state(Service *s, ServiceState state) {
795 ServiceState old_state;
e056b01d 796 const UnitActiveState *table;
842129f5 797
5cb5a6ff
LP		 798 assert(s);
799
e056b01d
LP		 800 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
801
034c6ed7 802 old_state = s->state;
5cb5a6ff 803 s->state = state;
034c6ed7 804
3a111838
MS		 805 service_unwatch_pid_file(s);
806
842129f5
LP		 807 if (!IN_SET(state,
808 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
809 SERVICE_RELOAD,
bf108e55 810 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 811 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
842129f5
LP		 812 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
813 SERVICE_AUTO_RESTART))
718db961 814 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
034c6ed7 815
842129f5
LP		 816 if (!IN_SET(state,
817 SERVICE_START, SERVICE_START_POST,
818 SERVICE_RUNNING, SERVICE_RELOAD,
bf108e55 819 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 820 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
bf108e55 821 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
5e94833f 822 service_unwatch_main_pid(s);
867b3b7d
LP		 823 s->main_command = NULL;
824 }
034c6ed7 825
842129f5
LP		 826 if (!IN_SET(state,
827 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
828 SERVICE_RELOAD,
bf108e55 829 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 830 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
842129f5 831 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
5e94833f 832 service_unwatch_control_pid(s);
034c6ed7 833 s->control_command = NULL;
a16e1123 834 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
e537352b 835 }
034c6ed7 836
a911bb9a
LP		 837 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
838 unit_unwatch_all_pids(UNIT(s));
839
842129f5
LP		 840 if (!IN_SET(state,
841 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
842 SERVICE_RUNNING, SERVICE_RELOAD,
843 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
db2cb23b 844 SERVICE_STOP_SIGABRT, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1124fe6f 845 !(state == SERVICE_DEAD && UNIT(s)->job)) {
4f2d528d 846 service_close_socket_fd(s);
6cf6bbc2
LP		 847 service_connection_unref(s);
848 }
4f2d528d 849
7596e9e1 850 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
a6927d7f
MO		 851 service_stop_watchdog(s);
852
f6023656
LP		 853 /* For the inactive states unit_notify() will trim the cgroup,
854 * but for exit we have to do that ourselves... */
1124fe6f 855 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
b1491eba 856 unit_destroy_cgroup_if_empty(UNIT(s));
f6023656 857
9cd86184
OB		 858 /* For remain_after_exit services, let's see if we can "release" the
859 * hold on the console, since unit_notify() only does that in case of
860 * change of state */
f49650ce
LP		 861 if (state == SERVICE_EXITED &&
862 s->remain_after_exit &&
9cd86184 863 UNIT(s)->manager->n_on_console > 0) {
f49650ce
LP		 864
865 ExecContext *ec;
866
867 ec = unit_get_exec_context(UNIT(s));
9cd86184
OB		 868 if (ec && exec_context_may_touch_console(ec)) {
869 Manager *m = UNIT(s)->manager;
870
871 m->n_on_console --;
872 if (m->n_on_console == 0)
873 /* unset no_console_output flag, since the console is free */
874 m->no_console_output = false;
875 }
876 }
877
e537352b 878 if (old_state != state)
79008bdd 879 log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
acbb0225 880
e056b01d 881 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
f42806df 882 s->reload_result = SERVICE_SUCCESS;
034c6ed7
LP		 883}
884
6e392c9c 885static int service_coldplug(Unit *u, Hashmap *deferred_work) {
a16e1123
LP		 886 Service *s = SERVICE(u);
887 int r;
888
889 assert(s);
890 assert(s->state == SERVICE_DEAD);
891
892 if (s->deserialized_state != s->state) {
893
bf108e55
LP		 894 if (IN_SET(s->deserialized_state,
895 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
896 SERVICE_RELOAD,
897 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 898 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
bf108e55 899 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
92c1622e
LP		 900
901 usec_t k;
6c12b52e 902
bf108e55 903 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
e558336f 904
92c1622e
LP		 905 /* For the start/stop timeouts 0 means off */
906 if (k > 0) {
907 r = service_arm_timer(s, k);
36697dc0 908 if (r < 0)
e558336f
LP		 909 return r;
910 }
911 }
a16e1123 912
92c1622e
LP		 913 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
914
915 /* The restart timeouts 0 means immediately */
916 r = service_arm_timer(s, s->restart_usec);
917 if (r < 0)
918 return r;
919 }
920
9f5650ae 921 if (pid_is_unwaited(s->main_pid) &&
bf108e55
LP		 922 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
923 IN_SET(s->deserialized_state,
924 SERVICE_START, SERVICE_START_POST,
925 SERVICE_RUNNING, SERVICE_RELOAD,
926 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 927 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
bf108e55
LP		 928 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
929 r = unit_watch_pid(UNIT(s), s->main_pid);
930 if (r < 0)
931 return r;
932 }
a16e1123 933
9f5650ae 934 if (pid_is_unwaited(s->control_pid) &&
bf108e55
LP		 935 IN_SET(s->deserialized_state,
936 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
937 SERVICE_RELOAD,
938 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
db2cb23b 939 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
bf108e55
LP		 940 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
941 r = unit_watch_pid(UNIT(s), s->control_pid);
942 if (r < 0)
943 return r;
944 }
a16e1123 945
a911bb9a
LP		 946 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
947 unit_watch_all_pids(UNIT(s));
948
842129f5
LP		 949 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
950 service_start_watchdog(s);
bb242b7b 951
a16e1123
LP		 952 service_set_state(s, s->deserialized_state);
953 }
92c1622e 954
a16e1123
LP		 955 return 0;
956}
957
44d8db9e 958static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
a354329f
LP		 959 _cleanup_free_ int *rfds = NULL;
960 unsigned rn_fds = 0;
44d8db9e
LP		 961 Iterator i;
962 int r;
57020a3a 963 Unit *u;
44d8db9e
LP		 964
965 assert(s);
966 assert(fds);
967 assert(n_fds);
968
6cf6bbc2
LP		 969 if (s->socket_fd >= 0)
970 return 0;
971
1124fe6f 972 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
44d8db9e
LP		 973 int *cfds;
974 unsigned cn_fds;
57020a3a
LP		 975 Socket *sock;
976
ac155bb8 977 if (u->type != UNIT_SOCKET)
57020a3a
LP		 978 continue;
979
980 sock = SOCKET(u);
44d8db9e 981
117dcc57
ZJS		 982 r = socket_collect_fds(sock, &cfds, &cn_fds);
983 if (r < 0)
a354329f 984 return r;
44d8db9e 985
a354329f
LP		 986 if (cn_fds <= 0) {
987 free(cfds);
44d8db9e 988 continue;
a354329f 989 }
44d8db9e
LP		 990
991 if (!rfds) {
992 rfds = cfds;
993 rn_fds = cn_fds;
994 } else {
995 int *t;
996
a354329f 997 t = realloc(rfds, (rn_fds + cn_fds) * sizeof(int));
117dcc57 998 if (!t) {
44d8db9e 999 free(cfds);
a354329f 1000 return -ENOMEM;
44d8db9e
LP		 1001 }
1002
a354329f
LP		 1003 memcpy(t + rn_fds, cfds, cn_fds * sizeof(int));
1004 rfds = t;
1005 rn_fds += cn_fds;
1006
44d8db9e
LP		 1007 free(cfds);
1008
44d8db9e
LP		 1009 }
1010 }
1011
a354329f
LP		 1012 if (s->n_fd_store > 0) {
1013 ServiceFDStore *fs;
1014 int *t;
1015
1016 t = realloc(rfds, (rn_fds + s->n_fd_store) * sizeof(int));
1017 if (!t)
1018 return -ENOMEM;
1019
1020 rfds = t;
1021 LIST_FOREACH(fd_store, fs, s->fd_store)
1022 rfds[rn_fds++] = fs->fd;
1023 }
1024
44d8db9e
LP		 1025 *fds = rfds;
1026 *n_fds = rn_fds;
3e33402a 1027
a354329f 1028 rfds = NULL;
44d8db9e 1029 return 0;
44d8db9e
LP		 1030}
1031
81a2b7ce
LP		 1032static int service_spawn(
1033 Service *s,
1034 ExecCommand *c,
21b2ce39 1035 usec_t timeout,
81a2b7ce
LP		 1036 bool pass_fds,
1037 bool apply_permissions,
1038 bool apply_chroot,
1e3ad081 1039 bool apply_tty_stdin,
ecedd90f 1040 bool is_control,
81a2b7ce
LP		 1041 pid_t *_pid) {
1042
034c6ed7
LP		 1043 pid_t pid;
1044 int r;
117dcc57 1045 int *fds = NULL;
7fd1b19b 1046 _cleanup_free_ int *fdsbuf = NULL;
2105e76a 1047 unsigned n_fds = 0, n_env = 0;
e44da745 1048 _cleanup_free_ char *bus_endpoint_path = NULL;
7fd1b19b 1049 _cleanup_strv_free_ char
117dcc57 1050 **argv = NULL, **final_env = NULL, **our_env = NULL;
4ad49000 1051 const char *path;
9fa95f85
DM		 1052 ExecParameters exec_params = {
1053 .apply_permissions = apply_permissions,
1054 .apply_chroot = apply_chroot,
1055 .apply_tty_stdin = apply_tty_stdin,
e44da745 1056 .bus_endpoint_fd = -1,
16115b0a 1057 .selinux_context_net = s->socket_fd_selinux_context_net
9fa95f85 1058 };
034c6ed7
LP		 1059
1060 assert(s);
1061 assert(c);
1062 assert(_pid);
1063
5ad096b3
LP		 1064 (void) unit_realize_cgroup(UNIT(s));
1065 if (s->reset_cpu_usage) {
1066 (void) unit_reset_cpu_usage(UNIT(s));
1067 s->reset_cpu_usage = false;
1068 }
4ad49000 1069
613b411c
LP		 1070 r = unit_setup_exec_runtime(UNIT(s));
1071 if (r < 0)
1072 goto fail;
1073
6cf6bbc2
LP		 1074 if (pass_fds ||
1075 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1076 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1077 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1078
4f2d528d
LP		 1079 if (s->socket_fd >= 0) {
1080 fds = &s->socket_fd;
1081 n_fds = 1;
6cf6bbc2 1082 } else {
117dcc57
ZJS		 1083 r = service_collect_fds(s, &fdsbuf, &n_fds);
1084 if (r < 0)
6cf6bbc2
LP		 1085 goto fail;
1086
1087 fds = fdsbuf;
1088 }
4f2d528d 1089 }
44d8db9e 1090
21b2ce39
LP		 1091 if (timeout > 0) {
1092 r = service_arm_timer(s, timeout);
92c1622e
LP		 1093 if (r < 0)
1094 goto fail;
1095 } else
1096 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
034c6ed7 1097
19f6d710
LP		 1098 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1099 if (r < 0)
9e2f7c11 1100 goto fail;
9e2f7c11 1101
3b1c5241 1102 our_env = new0(char*, 6);
97ae63e2 1103 if (!our_env) {
2105e76a
LP		 1104 r = -ENOMEM;
1105 goto fail;
1106 }
c952c6ec 1107
a158dbf1 1108 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
1124fe6f 1109 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
c952c6ec
LP		 1110 r = -ENOMEM;
1111 goto fail;
1112 }
1113
2105e76a 1114 if (s->main_pid > 0)
ccd06097 1115 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
c952c6ec
LP		 1116 r = -ENOMEM;
1117 goto fail;
1118 }
2105e76a 1119
4ad49000 1120 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
ccd06097 1121 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
97ae63e2
LP		 1122 r = -ENOMEM;
1123 goto fail;
1124 }
1125
3b1c5241
SL		 1126 if (UNIT_DEREF(s->accept_socket)) {
1127 union sockaddr_union sa;
1128 socklen_t salen = sizeof(sa);
1129
1130 r = getpeername(s->socket_fd, &sa.sa, &salen);
1131 if (r < 0) {
1132 r = -errno;
1133 goto fail;
1134 }
1135
1136 if (IN_SET(sa.sa.sa_family, AF_INET, AF_INET6)) {
1137 _cleanup_free_ char *addr = NULL;
1138 char *t;
1139 int port;
1140
1141 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1142 if (r < 0)
1143 goto fail;
1144
1145 t = strappend("REMOTE_ADDR=", addr);
1146 if (!t) {
1147 r = -ENOMEM;
1148 goto fail;
1149 }
1150 our_env[n_env++] = t;
1151
1152 port = sockaddr_port(&sa.sa);
1153 if (port < 0) {
1154 r = port;
1155 goto fail;
1156 }
1157
1158 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0) {
1159 r = -ENOMEM;
1160 goto fail;
1161 }
1162 our_env[n_env++] = t;
1163 }
1164 }
1165
97ae63e2
LP		 1166 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1167 if (!final_env) {
2105e76a
LP		 1168 r = -ENOMEM;
1169 goto fail;
1170 }
c952c6ec 1171
4ad49000 1172 if (is_control && UNIT(s)->cgroup_path) {
63c372cb 1173 path = strjoina(UNIT(s)->cgroup_path, "/control");
4ad49000
LP		 1174 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1175 } else
1176 path = UNIT(s)->cgroup_path;
1177
e44da745
DM		 1178#ifdef ENABLE_KDBUS
1179 if (s->exec_context.bus_endpoint) {
1180 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
1181 UNIT(s)->id, &bus_endpoint_path);
1182 if (r < 0)
1183 goto fail;
1184
1185 /* Pass the fd to the exec_params so that the child process can upload the policy.
1186 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1187 * as the service is running. */
1188 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
1189 }
1190#endif
1191
9fa95f85
DM		 1192 exec_params.argv = argv;
1193 exec_params.fds = fds;
1194 exec_params.n_fds = n_fds;
1195 exec_params.environment = final_env;
1196 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1197 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1198 exec_params.cgroup_path = path;
a931ad47 1199 exec_params.cgroup_delegate = s->cgroup_context.delegate;
9fa95f85
DM		 1200 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1201 exec_params.unit_id = UNIT(s)->id;
1202 exec_params.watchdog_usec = s->watchdog_usec;
e44da745 1203 exec_params.bus_endpoint_path = bus_endpoint_path;
9fa95f85
DM		 1204 if (s->type == SERVICE_IDLE)
1205 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1206
9e2f7c11 1207 r = exec_spawn(c,
9e2f7c11 1208 &s->exec_context,
9fa95f85 1209 &exec_params,
613b411c 1210 s->exec_runtime,
9e2f7c11 1211 &pid);
9e2f7c11 1212 if (r < 0)
034c6ed7
LP		 1213 goto fail;
1214
117dcc57
ZJS		 1215 r = unit_watch_pid(UNIT(s), pid);
1216 if (r < 0)
034c6ed7
LP		 1217 /* FIXME: we need to do something here */
1218 goto fail;
1219
1220 *_pid = pid;
1221
5cb5a6ff 1222 return 0;
034c6ed7
LP		 1223
1224fail:
1225 if (timeout)
718db961 1226 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
034c6ed7
LP		 1227
1228 return r;
1229}
1230
80876c20
LP		 1231static int main_pid_good(Service *s) {
1232 assert(s);
1233
1234 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1235 * don't know */
1236
1237 /* If we know the pid file, then lets just check if it is
1238 * still valid */
6dfa5494
LP		 1239 if (s->main_pid_known) {
1240
1241 /* If it's an alien child let's check if it is still
1242 * alive ... */
62220cf7 1243 if (s->main_pid_alien && s->main_pid > 0)
9f5650ae 1244 return pid_is_alive(s->main_pid);
6dfa5494
LP		 1245
1246 /* .. otherwise assume we'll get a SIGCHLD for it,
1247 * which we really should wait for to collect exit
1248 * status and code */
80876c20 1249 return s->main_pid > 0;
6dfa5494 1250 }
80876c20
LP		 1251
1252 /* We don't know the pid */
1253 return -EAGAIN;
1254}
1255
44a6b1b6 1256_pure_ static int control_pid_good(Service *s) {
80876c20
LP		 1257 assert(s);
1258
1259 return s->control_pid > 0;
1260}
1261
1262static int cgroup_good(Service *s) {
1263 int r;
1264
1265 assert(s);
1266
4ad49000
LP		 1267 if (!UNIT(s)->cgroup_path)
1268 return 0;
1269
1270 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
117dcc57 1271 if (r < 0)
80876c20
LP		 1272 return r;
1273
1274 return !r;
1275}
1276
f42806df 1277static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
034c6ed7
LP		 1278 int r;
1279 assert(s);
1280
f42806df
LP		 1281 if (f != SERVICE_SUCCESS)
1282 s->result = f;
034c6ed7 1283
0c7f15b3
MS		 1284 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1285
2928b0a8 1286 if (s->result != SERVICE_SUCCESS) {
79008bdd 1287 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
2928b0a8
LP		 1288 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1289 }
93ae25e6 1290
034c6ed7 1291 if (allow_restart &&
47342320 1292 !s->forbid_restart &&
034c6ed7 1293 (s->restart == SERVICE_RESTART_ALWAYS ||
f42806df
LP		 1294 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1295 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
6cfe2fde 1296 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
dc99a976 1297 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
37520c1b 1298 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
3e2d435b 1299 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
37520c1b 1300 (IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) && set_contains(s->restart_force_status.signal, INT_TO_PTR(s->main_exec_status.status)))) &&
3e2d435b 1301 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
37520c1b 1302 (!IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) || !set_contains(s->restart_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
034c6ed7 1303
718db961 1304 r = service_arm_timer(s, s->restart_usec);
f42806df 1305 if (r < 0)
034c6ed7
LP		 1306 goto fail;
1307
1308 service_set_state(s, SERVICE_AUTO_RESTART);
0c7f15b3 1309 }
034c6ed7 1310
47342320
LP		 1311 s->forbid_restart = false;
1312
e66cf1a3 1313 /* We want fresh tmpdirs in case service is started again immediately */
613b411c
LP		 1314 exec_runtime_destroy(s->exec_runtime);
1315 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
c17ec25e 1316
e66cf1a3
LP		 1317 /* Also, remove the runtime directory in */
1318 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1319
9285c9ff
LN		 1320 /* Try to delete the pid file. At this point it will be
1321 * out-of-date, and some software might be confused by it, so
1322 * let's remove it. */
1323 if (s->pid_file)
1324 unlink_noerrno(s->pid_file);
1325
034c6ed7
LP		 1326 return;
1327
1328fail:
31938a85 1329 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run install restart timer: %m", UNIT(s)->id);
f42806df 1330 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1331}
1332
f42806df 1333static void service_enter_stop_post(Service *s, ServiceResult f) {
034c6ed7
LP		 1334 int r;
1335 assert(s);
1336
f42806df
LP		 1337 if (f != SERVICE_SUCCESS)
1338 s->result = f;
034c6ed7 1339
5e94833f 1340 service_unwatch_control_pid(s);
a911bb9a 1341 unit_watch_all_pids(UNIT(s));
5e94833f 1342
117dcc57
ZJS		 1343 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1344 if (s->control_command) {
867b3b7d
LP		 1345 s->control_command_id = SERVICE_EXEC_STOP_POST;
1346
ecedd90f
LP		 1347 r = service_spawn(s,
1348 s->control_command,
21b2ce39 1349 s->timeout_stop_usec,
ecedd90f
LP		 1350 false,
1351 !s->permissions_start_only,
1352 !s->root_directory_start_only,
1353 true,
ecedd90f
LP		 1354 true,
1355 &s->control_pid);
1356 if (r < 0)
034c6ed7
LP		 1357 goto fail;
1358
80876c20
LP		 1359 service_set_state(s, SERVICE_STOP_POST);
1360 } else
ac84d1fb 1361 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 1362
1363 return;
1364
1365fail:
31938a85 1366 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop-post' task: %m", UNIT(s)->id);
f42806df 1367 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1368}
1369
f42806df 1370static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
034c6ed7 1371 int r;
034c6ed7
LP		 1372
1373 assert(s);
1374
f42806df
LP		 1375 if (f != SERVICE_SUCCESS)
1376 s->result = f;
034c6ed7 1377
a911bb9a
LP		 1378 unit_watch_all_pids(UNIT(s));
1379
cd2086fe
LP		 1380 r = unit_kill_context(
1381 UNIT(s),
1382 &s->kill_context,
db2cb23b
UTL		 1383 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1384 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
cd2086fe
LP		 1385 s->main_pid,
1386 s->control_pid,
1387 s->main_pid_alien);
ac84d1fb 1388
cd2086fe
LP		 1389 if (r < 0)
1390 goto fail;
034c6ed7 1391
cd2086fe 1392 if (r > 0) {
d568a335 1393 if (s->timeout_stop_usec > 0) {
718db961 1394 r = service_arm_timer(s, s->timeout_stop_usec);
d568a335 1395 if (r < 0)
e558336f 1396 goto fail;
d568a335 1397 }
d6ea93e3 1398
80876c20 1399 service_set_state(s, state);
db2cb23b 1400 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
ac84d1fb
LP		 1401 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1402 else if (state == SERVICE_STOP_SIGKILL)
f42806df 1403 service_enter_stop_post(s, SERVICE_SUCCESS);
ac84d1fb
LP		 1404 else if (state == SERVICE_FINAL_SIGTERM)
1405 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
80876c20 1406 else
f42806df 1407 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 1408
1409 return;
1410
1411fail:
31938a85 1412 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
034c6ed7 1413
db2cb23b
UTL		 1414 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1415 state == SERVICE_STOP_SIGABRT)
f42806df 1416 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
034c6ed7 1417 else
f42806df 1418 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 1419}
1420
308d72dc
LP		 1421static void service_enter_stop_by_notify(Service *s) {
1422 assert(s);
1423
1424 unit_watch_all_pids(UNIT(s));
1425
1426 if (s->timeout_stop_usec > 0)
1427 service_arm_timer(s, s->timeout_stop_usec);
1428
6041a7ee
MS		 1429 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1430 service_set_state(s, SERVICE_STOP_SIGTERM);
308d72dc
LP		 1431}
1432
f42806df 1433static void service_enter_stop(Service *s, ServiceResult f) {
034c6ed7 1434 int r;
5925dd3c 1435
034c6ed7
LP		 1436 assert(s);
1437
f42806df
LP		 1438 if (f != SERVICE_SUCCESS)
1439 s->result = f;
034c6ed7 1440
5e94833f 1441 service_unwatch_control_pid(s);
a911bb9a 1442 unit_watch_all_pids(UNIT(s));
5e94833f 1443
117dcc57
ZJS		 1444 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1445 if (s->control_command) {
867b3b7d
LP		 1446 s->control_command_id = SERVICE_EXEC_STOP;
1447
ecedd90f
LP		 1448 r = service_spawn(s,
1449 s->control_command,
21b2ce39 1450 s->timeout_stop_usec,
ecedd90f
LP		 1451 false,
1452 !s->permissions_start_only,
1453 !s->root_directory_start_only,
1454 false,
ecedd90f
LP		 1455 true,
1456 &s->control_pid);
1457 if (r < 0)
034c6ed7
LP		 1458 goto fail;
1459
80876c20
LP		 1460 service_set_state(s, SERVICE_STOP);
1461 } else
f42806df 1462 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 1463
1464 return;
1465
1466fail:
31938a85 1467 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop' task: %m", UNIT(s)->id);
f42806df 1468 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1469}
1470
f42806df 1471static void service_enter_running(Service *s, ServiceResult f) {
4eab639f 1472 int main_pid_ok, cgroup_ok;
80876c20
LP		 1473 assert(s);
1474
f42806df
LP		 1475 if (f != SERVICE_SUCCESS)
1476 s->result = f;
80876c20 1477
4eab639f
LP		 1478 main_pid_ok = main_pid_good(s);
1479 cgroup_ok = cgroup_good(s);
1480
1481 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
308d72dc
LP		 1482 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1483
1484 /* If there are any queued up sd_notify()
1485 * notifications, process them now */
1486 if (s->notify_state == NOTIFY_RELOADING)
1487 service_enter_reload_by_notify(s);
1488 else if (s->notify_state == NOTIFY_STOPPING)
1489 service_enter_stop_by_notify(s);
1490 else
1491 service_set_state(s, SERVICE_RUNNING);
1492
1493 } else if (s->remain_after_exit)
80876c20
LP		 1494 service_set_state(s, SERVICE_EXITED);
1495 else
f42806df 1496 service_enter_stop(s, SERVICE_SUCCESS);
80876c20
LP		 1497}
1498
034c6ed7
LP		 1499static void service_enter_start_post(Service *s) {
1500 int r;
1501 assert(s);
1502
5e94833f 1503 service_unwatch_control_pid(s);
842129f5 1504 service_reset_watchdog(s);
bb242b7b 1505
117dcc57
ZJS		 1506 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1507 if (s->control_command) {
867b3b7d
LP		 1508 s->control_command_id = SERVICE_EXEC_START_POST;
1509
ecedd90f
LP		 1510 r = service_spawn(s,
1511 s->control_command,
21b2ce39 1512 s->timeout_start_usec,
ecedd90f
LP		 1513 false,
1514 !s->permissions_start_only,
1515 !s->root_directory_start_only,
1516 false,
ecedd90f
LP		 1517 true,
1518 &s->control_pid);
1519 if (r < 0)
034c6ed7
LP		 1520 goto fail;
1521
80876c20
LP		 1522 service_set_state(s, SERVICE_START_POST);
1523 } else
f42806df 1524 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 1525
1526 return;
1527
1528fail:
31938a85 1529 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-post' task: %m", UNIT(s)->id);
f42806df 1530 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1531}
1532
4ad49000
LP		 1533static void service_kill_control_processes(Service *s) {
1534 char *p;
1535
1536 if (!UNIT(s)->cgroup_path)
1537 return;
1538
63c372cb 1539 p = strjoina(UNIT(s)->cgroup_path, "/control");
4ad49000
LP		 1540 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1541}
1542
034c6ed7 1543static void service_enter_start(Service *s) {
4ad49000 1544 ExecCommand *c;
034c6ed7
LP		 1545 pid_t pid;
1546 int r;
1547
1548 assert(s);
1549
41efeaec
LP		 1550 service_unwatch_control_pid(s);
1551 service_unwatch_main_pid(s);
80876c20 1552
8f53a7b8
LP		 1553 /* We want to ensure that nobody leaks processes from
1554 * START_PRE here, so let's go on a killing spree, People
1555 * should not spawn long running processes from START_PRE. */
4ad49000 1556 service_kill_control_processes(s);
8f53a7b8 1557
867b3b7d
LP		 1558 if (s->type == SERVICE_FORKING) {
1559 s->control_command_id = SERVICE_EXEC_START;
1560 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1561
1562 s->main_command = NULL;
1563 } else {
1564 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1565 s->control_command = NULL;
1566
1567 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1568 }
34e9ba66 1569
96fb8242
LP		 1570 if (!c) {
1571 assert(s->type == SERVICE_ONESHOT);
1572 service_enter_start_post(s);
1573 return;
1574 }
1575
ecedd90f
LP		 1576 r = service_spawn(s,
1577 c,
21b2ce39 1578 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
ecedd90f
LP		 1579 true,
1580 true,
1581 true,
1582 true,
ecedd90f
LP		 1583 false,
1584 &pid);
1585 if (r < 0)
034c6ed7
LP		 1586 goto fail;
1587
f2b68789 1588 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
034c6ed7
LP		 1589 /* For simple services we immediately start
1590 * the START_POST binaries. */
1591
5925dd3c 1592 service_set_main_pid(s, pid);
034c6ed7
LP		 1593 service_enter_start_post(s);
1594
1595 } else if (s->type == SERVICE_FORKING) {
1596
1597 /* For forking services we wait until the start
1598 * process exited. */
1599
e55224ca 1600 s->control_pid = pid;
80876c20
LP		 1601 service_set_state(s, SERVICE_START);
1602
34e9ba66 1603 } else if (s->type == SERVICE_ONESHOT ||
8c47c732
LP		 1604 s->type == SERVICE_DBUS ||
1605 s->type == SERVICE_NOTIFY) {
7d55e835 1606
34e9ba66 1607 /* For oneshot services we wait until the start
7d55e835
LP		 1608 * process exited, too, but it is our main process. */
1609
05e343b7 1610 /* For D-Bus services we know the main pid right away,
8c47c732
LP		 1611 * but wait for the bus name to appear on the
1612 * bus. Notify services are similar. */
05e343b7 1613
5925dd3c 1614 service_set_main_pid(s, pid);
80876c20 1615 service_set_state(s, SERVICE_START);
034c6ed7
LP		 1616 } else
1617 assert_not_reached("Unknown service type");
1618
1619 return;
1620
1621fail:
31938a85 1622 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start' task: %m", UNIT(s)->id);
f42806df 1623 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1624}
1625
1626static void service_enter_start_pre(Service *s) {
1627 int r;
1628
1629 assert(s);
1630
5e94833f
LP		 1631 service_unwatch_control_pid(s);
1632
117dcc57
ZJS		 1633 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1634 if (s->control_command) {
8f53a7b8
LP		 1635 /* Before we start anything, let's clear up what might
1636 * be left from previous runs. */
4ad49000 1637 service_kill_control_processes(s);
8f53a7b8 1638
867b3b7d
LP		 1639 s->control_command_id = SERVICE_EXEC_START_PRE;
1640
ecedd90f
LP		 1641 r = service_spawn(s,
1642 s->control_command,
21b2ce39 1643 s->timeout_start_usec,
ecedd90f
LP		 1644 false,
1645 !s->permissions_start_only,
1646 !s->root_directory_start_only,
1647 true,
ecedd90f
LP		 1648 true,
1649 &s->control_pid);
1650 if (r < 0)
034c6ed7
LP		 1651 goto fail;
1652
80876c20
LP		 1653 service_set_state(s, SERVICE_START_PRE);
1654 } else
034c6ed7
LP		 1655 service_enter_start(s);
1656
1657 return;
1658
1659fail:
31938a85 1660 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-pre' task: %m", UNIT(s)->id);
f42806df 1661 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 1662}
1663
1664static void service_enter_restart(Service *s) {
718db961 1665 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
034c6ed7 1666 int r;
398ef8ba 1667
034c6ed7
LP		 1668 assert(s);
1669
a8bb2e65
LP		 1670 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1671 /* Don't restart things if we are going down anyway */
79008bdd 1672 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
2edfa366 1673
718db961 1674 r = service_arm_timer(s, s->restart_usec);
a8bb2e65 1675 if (r < 0)
2edfa366 1676 goto fail;
feae8adb
DW		 1677
1678 return;
2edfa366
LP		 1679 }
1680
48bb5876
DW		 1681 /* Any units that are bound to this service must also be
1682 * restarted. We use JOB_RESTART (instead of the more obvious
1683 * JOB_START) here so that those dependency jobs will be added
1684 * as well. */
1685 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1686 if (r < 0)
034c6ed7
LP		 1687 goto fail;
1688
a8bb2e65
LP		 1689 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1690 * it will be canceled as part of the service_stop() call that
1691 * is executed as part of JOB_RESTART. */
1692
79008bdd 1693 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
034c6ed7
LP		 1694 return;
1695
1696fail:
79008bdd 1697 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
f42806df 1698 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1699}
1700
308d72dc
LP		 1701static void service_enter_reload_by_notify(Service *s) {
1702 assert(s);
1703
1704 if (s->timeout_start_usec > 0)
1705 service_arm_timer(s, s->timeout_start_usec);
1706
1707 service_set_state(s, SERVICE_RELOAD);
1708}
1709
034c6ed7
LP		 1710static void service_enter_reload(Service *s) {
1711 int r;
1712
1713 assert(s);
1714
5e94833f
LP		 1715 service_unwatch_control_pid(s);
1716
117dcc57
ZJS		 1717 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1718 if (s->control_command) {
867b3b7d
LP		 1719 s->control_command_id = SERVICE_EXEC_RELOAD;
1720
ecedd90f
LP		 1721 r = service_spawn(s,
1722 s->control_command,
21b2ce39 1723 s->timeout_start_usec,
ecedd90f
LP		 1724 false,
1725 !s->permissions_start_only,
1726 !s->root_directory_start_only,
1727 false,
ecedd90f
LP		 1728 true,
1729 &s->control_pid);
1730 if (r < 0)
034c6ed7
LP		 1731 goto fail;
1732
80876c20
LP		 1733 service_set_state(s, SERVICE_RELOAD);
1734 } else
f42806df 1735 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 1736
1737 return;
1738
1739fail:
31938a85 1740 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'reload' task: %m", UNIT(s)->id);
f42806df
LP		 1741 s->reload_result = SERVICE_FAILURE_RESOURCES;
1742 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 1743}
1744
f42806df 1745static void service_run_next_control(Service *s) {
034c6ed7
LP		 1746 int r;
1747
1748 assert(s);
1749 assert(s->control_command);
1750 assert(s->control_command->command_next);
1751
34e9ba66 1752 assert(s->control_command_id != SERVICE_EXEC_START);
034c6ed7 1753
34e9ba66 1754 s->control_command = s->control_command->command_next;
5e94833f
LP		 1755 service_unwatch_control_pid(s);
1756
ecedd90f
LP		 1757 r = service_spawn(s,
1758 s->control_command,
21b2ce39 1759 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
ecedd90f
LP		 1760 false,
1761 !s->permissions_start_only,
1762 !s->root_directory_start_only,
1763 s->control_command_id == SERVICE_EXEC_START_PRE ||
1764 s->control_command_id == SERVICE_EXEC_STOP_POST,
ecedd90f
LP		 1765 true,
1766 &s->control_pid);
1767 if (r < 0)
034c6ed7
LP		 1768 goto fail;
1769
1770 return;
1771
1772fail:
31938a85 1773 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next control task: %m", UNIT(s)->id);
034c6ed7 1774
80876c20 1775 if (s->state == SERVICE_START_PRE)
f42806df 1776 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
80876c20 1777 else if (s->state == SERVICE_STOP)
f42806df 1778 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7 1779 else if (s->state == SERVICE_STOP_POST)
f42806df 1780 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
e2f3b44c 1781 else if (s->state == SERVICE_RELOAD) {
f42806df
LP		 1782 s->reload_result = SERVICE_FAILURE_RESOURCES;
1783 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c 1784 } else
f42806df 1785 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
5cb5a6ff
LP		 1786}
1787
f42806df 1788static void service_run_next_main(Service *s) {
34e9ba66
LP		 1789 pid_t pid;
1790 int r;
1791
1792 assert(s);
867b3b7d
LP		 1793 assert(s->main_command);
1794 assert(s->main_command->command_next);
1795 assert(s->type == SERVICE_ONESHOT);
34e9ba66 1796
867b3b7d 1797 s->main_command = s->main_command->command_next;
34e9ba66
LP		 1798 service_unwatch_main_pid(s);
1799
ecedd90f
LP		 1800 r = service_spawn(s,
1801 s->main_command,
21b2ce39 1802 s->timeout_start_usec,
ecedd90f
LP		 1803 true,
1804 true,
1805 true,
1806 true,
ecedd90f
LP		 1807 false,
1808 &pid);
1809 if (r < 0)
34e9ba66
LP		 1810 goto fail;
1811
1812 service_set_main_pid(s, pid);
1813
1814 return;
1815
1816fail:
31938a85 1817 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next main task: %m", UNIT(s)->id);
f42806df 1818 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
34e9ba66
LP		 1819}
1820
93ae25e6
MO		 1821static int service_start_limit_test(Service *s) {
1822 assert(s);
1823
1824 if (ratelimit_test(&s->start_limit))
1825 return 0;
1826
79008bdd 1827 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
2928b0a8
LP		 1828
1829 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
93ae25e6
MO		 1830}
1831
87f0e418
LP		 1832static int service_start(Unit *u) {
1833 Service *s = SERVICE(u);
4b939747 1834 int r;
5cb5a6ff
LP		 1835
1836 assert(s);
1837
034c6ed7
LP		 1838 /* We cannot fulfill this request right now, try again later
1839 * please! */
1840 if (s->state == SERVICE_STOP ||
db2cb23b 1841 s->state == SERVICE_STOP_SIGABRT ||
034c6ed7
LP		 1842 s->state == SERVICE_STOP_SIGTERM ||
1843 s->state == SERVICE_STOP_SIGKILL ||
1844 s->state == SERVICE_STOP_POST ||
1845 s->state == SERVICE_FINAL_SIGTERM ||
1846 s->state == SERVICE_FINAL_SIGKILL)
5cb5a6ff
LP		 1847 return -EAGAIN;
1848
034c6ed7
LP		 1849 /* Already on it! */
1850 if (s->state == SERVICE_START_PRE ||
1851 s->state == SERVICE_START ||
1852 s->state == SERVICE_START_POST)
1853 return 0;
1854
2e9d6c12 1855 /* A service that will be restarted must be stopped first to
7f2cddae 1856 * trigger BindsTo and/or OnFailure dependencies. If a user
2e9d6c12 1857 * does not want to wait for the holdoff time to elapse, the
d4943dc7
LP		 1858 * service should be manually restarted, not started. We
1859 * simply return EAGAIN here, so that any start jobs stay
1860 * queued, and assume that the auto restart timer will
1861 * eventually trigger the restart. */
1862 if (s->state == SERVICE_AUTO_RESTART)
a8bb2e65 1863 return -EAGAIN;
2e9d6c12
DW		 1864
1865 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
5cb5a6ff 1866
1e2e8133 1867 /* Make sure we don't enter a busy loop of some kind. */
4b939747 1868 r = service_start_limit_test(s);
c2f34808 1869 if (r < 0) {
8d1b002a 1870 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
4b939747 1871 return r;
c2f34808 1872 }
1e2e8133 1873
f42806df
LP		 1874 s->result = SERVICE_SUCCESS;
1875 s->reload_result = SERVICE_SUCCESS;
034c6ed7 1876 s->main_pid_known = false;
6dfa5494 1877 s->main_pid_alien = false;
47342320 1878 s->forbid_restart = false;
5ad096b3 1879 s->reset_cpu_usage = true;
034c6ed7 1880
8cfdb077
LP		 1881 free(s->status_text);
1882 s->status_text = NULL;
1883 s->status_errno = 0;
1884
308d72dc
LP		 1885 s->notify_state = NOTIFY_UNKNOWN;
1886
034c6ed7 1887 service_enter_start_pre(s);
82a2b6bb 1888 return 1;
5cb5a6ff
LP		 1889}
1890
87f0e418
LP		 1891static int service_stop(Unit *u) {
1892 Service *s = SERVICE(u);
5cb5a6ff
LP		 1893
1894 assert(s);
1895
f0c7b229 1896 /* Don't create restart jobs from here. */
47342320 1897 s->forbid_restart = true;
034c6ed7 1898
e537352b
LP		 1899 /* Already on it */
1900 if (s->state == SERVICE_STOP ||
db2cb23b 1901 s->state == SERVICE_STOP_SIGABRT ||
e537352b
LP		 1902 s->state == SERVICE_STOP_SIGTERM ||
1903 s->state == SERVICE_STOP_SIGKILL ||
1904 s->state == SERVICE_STOP_POST ||
1905 s->state == SERVICE_FINAL_SIGTERM ||
1906 s->state == SERVICE_FINAL_SIGKILL)
1907 return 0;
1908
f0c7b229 1909 /* A restart will be scheduled or is in progress. */
034c6ed7 1910 if (s->state == SERVICE_AUTO_RESTART) {
0c7f15b3 1911 service_set_state(s, SERVICE_DEAD);
034c6ed7
LP		 1912 return 0;
1913 }
1914
3f6c78dc
LP		 1915 /* If there's already something running we go directly into
1916 * kill mode. */
1917 if (s->state == SERVICE_START_PRE ||
1918 s->state == SERVICE_START ||
1919 s->state == SERVICE_START_POST ||
1920 s->state == SERVICE_RELOAD) {
f42806df 1921 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
3f6c78dc
LP		 1922 return 0;
1923 }
5cb5a6ff 1924
3f6c78dc
LP		 1925 assert(s->state == SERVICE_RUNNING ||
1926 s->state == SERVICE_EXITED);
3a762661 1927
f42806df 1928 service_enter_stop(s, SERVICE_SUCCESS);
82a2b6bb 1929 return 1;
5cb5a6ff
LP		 1930}
1931
87f0e418
LP		 1932static int service_reload(Unit *u) {
1933 Service *s = SERVICE(u);
034c6ed7
LP		 1934
1935 assert(s);
1936
80876c20 1937 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
034c6ed7
LP		 1938
1939 service_enter_reload(s);
5cb5a6ff
LP		 1940 return 0;
1941}
1942
44a6b1b6 1943_pure_ static bool service_can_reload(Unit *u) {
87f0e418 1944 Service *s = SERVICE(u);
034c6ed7
LP		 1945
1946 assert(s);
1947
1948 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1949}
1950
a16e1123
LP		 1951static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1952 Service *s = SERVICE(u);
2339fc93 1953 ServiceFDStore *fs;
a16e1123
LP		 1954
1955 assert(u);
1956 assert(f);
1957 assert(fds);
1958
1959 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
f42806df
LP		 1960 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1961 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
a16e1123
LP		 1962
1963 if (s->control_pid > 0)
ccd06097
ZJS		 1964 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1965 s->control_pid);
a16e1123 1966
5925dd3c 1967 if (s->main_pid_known && s->main_pid > 0)
ccd06097 1968 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
a16e1123
LP		 1969
1970 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1971
3a2776bc
LP		 1972 if (s->status_text)
1973 unit_serialize_item(u, f, "status-text", s->status_text);
1974
cfc4eb4c
LP		 1975 /* FIXME: There's a minor uncleanliness here: if there are
1976 * multiple commands attached here, we will start from the
1977 * first one again */
a16e1123 1978 if (s->control_command_id >= 0)
117dcc57
ZJS		 1979 unit_serialize_item(u, f, "control-command",
1980 service_exec_command_to_string(s->control_command_id));
a16e1123
LP		 1981
1982 if (s->socket_fd >= 0) {
1983 int copy;
1984
2339fc93
LP		 1985 copy = fdset_put_dup(fds, s->socket_fd);
1986 if (copy < 0)
a16e1123
LP		 1987 return copy;
1988
1989 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1990 }
1991
e44da745
DM		 1992 if (s->bus_endpoint_fd >= 0) {
1993 int copy;
1994
2339fc93
LP		 1995 copy = fdset_put_dup(fds, s->bus_endpoint_fd);
1996 if (copy < 0)
e44da745
DM		 1997 return copy;
1998
1999 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
2000 }
2001
2339fc93
LP		 2002 LIST_FOREACH(fd_store, fs, s->fd_store) {
2003 int copy;
2004
2005 copy = fdset_put_dup(fds, fs->fd);
2006 if (copy < 0)
2007 return copy;
2008
2009 unit_serialize_item_format(u, f, "fd-store-fd", "%i", copy);
2010 }
2011
ecdbca40 2012 if (s->main_exec_status.pid > 0) {
ccd06097
ZJS		 2013 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2014 s->main_exec_status.pid);
117dcc57
ZJS		 2015 dual_timestamp_serialize(f, "main-exec-status-start",
2016 &s->main_exec_status.start_timestamp);
2017 dual_timestamp_serialize(f, "main-exec-status-exit",
2018 &s->main_exec_status.exit_timestamp);
ecdbca40 2019
799fd0fd 2020 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
117dcc57
ZJS		 2021 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2022 s->main_exec_status.code);
2023 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2024 s->main_exec_status.status);
ecdbca40
LP		 2025 }
2026 }
a6927d7f 2027 if (dual_timestamp_is_set(&s->watchdog_timestamp))
842129f5 2028 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
ecdbca40 2029
6aca9a58 2030 if (s->forbid_restart)
8d1a2802 2031 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
6aca9a58 2032
a16e1123
LP		 2033 return 0;
2034}
2035
2036static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2037 Service *s = SERVICE(u);
2339fc93 2038 int r;
a16e1123
LP		 2039
2040 assert(u);
2041 assert(key);
2042 assert(value);
2043 assert(fds);
2044
2045 if (streq(key, "state")) {
2046 ServiceState state;
2047
117dcc57
ZJS		 2048 state = service_state_from_string(value);
2049 if (state < 0)
79008bdd 2050 log_unit_debug(u->id, "Failed to parse state value %s", value);
a16e1123
LP		 2051 else
2052 s->deserialized_state = state;
f42806df
LP		 2053 } else if (streq(key, "result")) {
2054 ServiceResult f;
2055
2056 f = service_result_from_string(value);
2057 if (f < 0)
79008bdd 2058 log_unit_debug(u->id, "Failed to parse result value %s", value);
f42806df
LP		 2059 else if (f != SERVICE_SUCCESS)
2060 s->result = f;
2061
2062 } else if (streq(key, "reload-result")) {
2063 ServiceResult f;
2064
2065 f = service_result_from_string(value);
2066 if (f < 0)
79008bdd 2067 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
f42806df
LP		 2068 else if (f != SERVICE_SUCCESS)
2069 s->reload_result = f;
a16e1123 2070
a16e1123 2071 } else if (streq(key, "control-pid")) {
5925dd3c 2072 pid_t pid;
a16e1123 2073
e364ad06 2074 if (parse_pid(value, &pid) < 0)
79008bdd 2075 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
a16e1123 2076 else
e55224ca 2077 s->control_pid = pid;
a16e1123 2078 } else if (streq(key, "main-pid")) {
5925dd3c 2079 pid_t pid;
a16e1123 2080
e364ad06 2081 if (parse_pid(value, &pid) < 0)
79008bdd 2082 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
7400b9d2
LP		 2083 else {
2084 service_set_main_pid(s, pid);
2085 unit_watch_pid(UNIT(s), pid);
2086 }
a16e1123
LP		 2087 } else if (streq(key, "main-pid-known")) {
2088 int b;
2089
117dcc57
ZJS		 2090 b = parse_boolean(value);
2091 if (b < 0)
79008bdd 2092 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
a16e1123
LP		 2093 else
2094 s->main_pid_known = b;
3a2776bc
LP		 2095 } else if (streq(key, "status-text")) {
2096 char *t;
2097
117dcc57
ZJS		 2098 t = strdup(value);
2099 if (!t)
2100 log_oom();
2101 else {
3a2776bc
LP		 2102 free(s->status_text);
2103 s->status_text = t;
2104 }
2105
a16e1123
LP		 2106 } else if (streq(key, "control-command")) {
2107 ServiceExecCommand id;
2108
117dcc57
ZJS		 2109 id = service_exec_command_from_string(value);
2110 if (id < 0)
79008bdd 2111 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
a16e1123
LP		 2112 else {
2113 s->control_command_id = id;
2114 s->control_command = s->exec_command[id];
2115 }
2116 } else if (streq(key, "socket-fd")) {
2117 int fd;
2118
2119 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
79008bdd 2120 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
a16e1123 2121 else {
574634bc 2122 asynchronous_close(s->socket_fd);
a16e1123
LP		 2123 s->socket_fd = fdset_remove(fds, fd);
2124 }
e44da745
DM		 2125 } else if (streq(key, "endpoint-fd")) {
2126 int fd;
2127
2128 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
79008bdd 2129 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
e44da745
DM		 2130 else {
2131 safe_close(s->bus_endpoint_fd);
2132 s->bus_endpoint_fd = fdset_remove(fds, fd);
2133 }
2339fc93
LP		 2134 } else if (streq(key, "fd-store-fd")) {
2135 int fd;
2136
2137 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2138 log_unit_debug(u->id, "Failed to parse fd-store-fd value %s", value);
2139 else {
2140 r = service_add_fd_store(s, fd);
2141 if (r < 0)
2142 log_unit_error_errno(u->id, r, "Failed to add fd to store: %m");
2143 else if (r > 0)
2144 fdset_remove(fds, fd);
2145 }
2146
ecdbca40
LP		 2147 } else if (streq(key, "main-exec-status-pid")) {
2148 pid_t pid;
2149
e364ad06 2150 if (parse_pid(value, &pid) < 0)
79008bdd 2151 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
ecdbca40
LP		 2152 else
2153 s->main_exec_status.pid = pid;
2154 } else if (streq(key, "main-exec-status-code")) {
2155 int i;
2156
e364ad06 2157 if (safe_atoi(value, &i) < 0)
79008bdd 2158 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
ecdbca40
LP		 2159 else
2160 s->main_exec_status.code = i;
2161 } else if (streq(key, "main-exec-status-status")) {
2162 int i;
2163
e364ad06 2164 if (safe_atoi(value, &i) < 0)
79008bdd 2165 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
ecdbca40
LP		 2166 else
2167 s->main_exec_status.status = i;
799fd0fd
LP		 2168 } else if (streq(key, "main-exec-status-start"))
2169 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2170 else if (streq(key, "main-exec-status-exit"))
2171 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
a6927d7f
MO		 2172 else if (streq(key, "watchdog-timestamp"))
2173 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
613b411c 2174 else if (streq(key, "forbid-restart")) {
6aca9a58
SE		 2175 int b;
2176
2177 b = parse_boolean(value);
2178 if (b < 0)
79008bdd 2179 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
6aca9a58
SE		 2180 else
2181 s->forbid_restart = b;
c17ec25e 2182 } else
79008bdd 2183 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
a16e1123
LP		 2184
2185 return 0;
2186}
2187
44a6b1b6 2188_pure_ static UnitActiveState service_active_state(Unit *u) {
e056b01d
LP		 2189 const UnitActiveState *table;
2190
87f0e418 2191 assert(u);
5cb5a6ff 2192
e056b01d
LP		 2193 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2194
2195 return table[SERVICE(u)->state];
034c6ed7
LP		 2196}
2197
10a94420
LP		 2198static const char *service_sub_state_to_string(Unit *u) {
2199 assert(u);
2200
2201 return service_state_to_string(SERVICE(u)->state);
2202}
2203
701cc384
LP		 2204static bool service_check_gc(Unit *u) {
2205 Service *s = SERVICE(u);
2206
2207 assert(s);
2208
6d55002a
LP		 2209 /* Never clean up services that still have a process around,
2210 * even if the service is formally dead. */
2211 if (cgroup_good(s) > 0 ||
2212 main_pid_good(s) > 0 ||
2213 control_pid_good(s) > 0)
2214 return true;
2215
6d55002a
LP		 2216 return false;
2217}
2218
44a6b1b6 2219_pure_ static bool service_check_snapshot(Unit *u) {
701cc384
LP		 2220 Service *s = SERVICE(u);
2221
2222 assert(s);
2223
8bb2d17d 2224 return s->socket_fd < 0;
701cc384
LP		 2225}
2226
3a111838
MS		 2227static int service_retry_pid_file(Service *s) {
2228 int r;
2229
2230 assert(s->pid_file);
2231 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2232
2233 r = service_load_pid_file(s, false);
2234 if (r < 0)
2235 return r;
2236
2237 service_unwatch_pid_file(s);
2238
f42806df 2239 service_enter_running(s, SERVICE_SUCCESS);
3a111838
MS		 2240 return 0;
2241}
2242
2243static int service_watch_pid_file(Service *s) {
2244 int r;
2245
79008bdd 2246 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
8bb2d17d 2247
718db961 2248 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
3a111838
MS		 2249 if (r < 0)
2250 goto fail;
2251
2252 /* the pidfile might have appeared just before we set the watch */
79008bdd 2253 log_unit_debug(UNIT(s)->id, "Trying to read %s's PID file %s in case it changed", UNIT(s)->id, s->pid_file_pathspec->path);
3a111838
MS		 2254 service_retry_pid_file(s);
2255
2256 return 0;
2257fail:
31938a85 2258 log_unit_error_errno(UNIT(s)->id, r, "Failed to set a watch for %s's PID file %s: %m", UNIT(s)->id, s->pid_file_pathspec->path);
3a111838
MS		 2259 service_unwatch_pid_file(s);
2260 return r;
2261}
2262
2263static int service_demand_pid_file(Service *s) {
2264 PathSpec *ps;
2265
2266 assert(s->pid_file);
2267 assert(!s->pid_file_pathspec);
2268
2269 ps = new0(PathSpec, 1);
2270 if (!ps)
2271 return -ENOMEM;
2272
718db961 2273 ps->unit = UNIT(s);
3a111838
MS		 2274 ps->path = strdup(s->pid_file);
2275 if (!ps->path) {
2276 free(ps);
2277 return -ENOMEM;
2278 }
2279
2280 path_kill_slashes(ps->path);
2281
2282 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2283 * keep their PID file open all the time. */
2284 ps->type = PATH_MODIFIED;
2285 ps->inotify_fd = -1;
2286
2287 s->pid_file_pathspec = ps;
2288
2289 return service_watch_pid_file(s);
2290}
2291
718db961 2292static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
e14c2802
LP		 2293 PathSpec *p = userdata;
2294 Service *s;
2295
2296 assert(p);
2297
2298 s = SERVICE(p->unit);
3a111838
MS		 2299
2300 assert(s);
2301 assert(fd >= 0);
2302 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2303 assert(s->pid_file_pathspec);
57020a3a 2304 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3a111838 2305
79008bdd 2306 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
3a111838 2307
e14c2802 2308 if (path_spec_fd_event(p, events) < 0)
3a111838
MS		 2309 goto fail;
2310
2311 if (service_retry_pid_file(s) == 0)
718db961 2312 return 0;
3a111838
MS		 2313
2314 if (service_watch_pid_file(s) < 0)
2315 goto fail;
2316
718db961
LP		 2317 return 0;
2318
3a111838
MS		 2319fail:
2320 service_unwatch_pid_file(s);
f42806df 2321 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
718db961 2322 return 0;
3a111838
MS		 2323}
2324
a911bb9a
LP		 2325static void service_notify_cgroup_empty_event(Unit *u) {
2326 Service *s = SERVICE(u);
2327
2328 assert(u);
2329
79008bdd 2330 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
a911bb9a
LP		 2331
2332 switch (s->state) {
2333
2334 /* Waiting for SIGCHLD is usually more interesting,
2335 * because it includes return codes/signals. Which is
2336 * why we ignore the cgroup events for most cases,
2337 * except when we don't know pid which to expect the
2338 * SIGCHLD for. */
2339
2340 case SERVICE_START:
2341 case SERVICE_START_POST:
2342 /* If we were hoping for the daemon to write its PID file,
2343 * we can give up now. */
2344 if (s->pid_file_pathspec) {
79008bdd 2345 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
8bb2d17d 2346
a911bb9a
LP		 2347 service_unwatch_pid_file(s);
2348 if (s->state == SERVICE_START)
2349 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2350 else
2351 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2352 }
2353 break;
2354
2355 case SERVICE_RUNNING:
2356 /* service_enter_running() will figure out what to do */
2357 service_enter_running(s, SERVICE_SUCCESS);
2358 break;
2359
db2cb23b 2360 case SERVICE_STOP_SIGABRT:
a911bb9a
LP		 2361 case SERVICE_STOP_SIGTERM:
2362 case SERVICE_STOP_SIGKILL:
2363
2364 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2365 service_enter_stop_post(s, SERVICE_SUCCESS);
2366
2367 break;
2368
2369 case SERVICE_STOP_POST:
2370 case SERVICE_FINAL_SIGTERM:
2371 case SERVICE_FINAL_SIGKILL:
2372 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2373 service_enter_dead(s, SERVICE_SUCCESS, true);
2374
2375 break;
2376
2377 default:
2378 ;
2379 }
2380}
2381
87f0e418
LP		 2382static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2383 Service *s = SERVICE(u);
f42806df 2384 ServiceResult f;
5cb5a6ff
LP		 2385
2386 assert(s);
034c6ed7
LP		 2387 assert(pid >= 0);
2388
96342de6
LN		 2389 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2390 is_clean_exit_lsb(code, status, &s->success_status))
f42806df
LP		 2391 f = SERVICE_SUCCESS;
2392 else if (code == CLD_EXITED)
2393 f = SERVICE_FAILURE_EXIT_CODE;
2394 else if (code == CLD_KILLED)
2395 f = SERVICE_FAILURE_SIGNAL;
2396 else if (code == CLD_DUMPED)
2397 f = SERVICE_FAILURE_CORE_DUMP;
d06dacd0 2398 else
cfc4eb4c 2399 assert_not_reached("Unknown code");
034c6ed7
LP		 2400
2401 if (s->main_pid == pid) {
db01f8b3
MS		 2402 /* Forking services may occasionally move to a new PID.
2403 * As long as they update the PID file before exiting the old
2404 * PID, they're fine. */
5375410b 2405 if (service_load_pid_file(s, false) == 0)
db01f8b3 2406 return;
034c6ed7 2407
034c6ed7 2408 s->main_pid = 0;
6ea832a2 2409 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
034c6ed7 2410
867b3b7d 2411 if (s->main_command) {
fbeefb45
LP		 2412 /* If this is not a forking service than the
2413 * main process got started and hence we copy
2414 * the exit status so that it is recorded both
2415 * as main and as control process exit
2416 * status */
2417
867b3b7d 2418 s->main_command->exec_status = s->main_exec_status;
b708e7ce 2419
867b3b7d 2420 if (s->main_command->ignore)
f42806df 2421 f = SERVICE_SUCCESS;
fbeefb45
LP		 2422 } else if (s->exec_command[SERVICE_EXEC_START]) {
2423
2424 /* If this is a forked process, then we should
2425 * ignore the return value if this was
2426 * configured for the starter process */
2427
2428 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2429 f = SERVICE_SUCCESS;
034c6ed7
LP		 2430 }
2431
e2cc6eca
LP		 2432 log_unit_struct(u->id,
2433 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2434 LOG_MESSAGE("%s: main process exited, code=%s, status=%i/%s",
2435 u->id, sigchld_code_to_string(code), status,
2436 strna(code == CLD_EXITED
2437 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2438 : signal_to_string(status))),
2439 "EXIT_CODE=%s", sigchld_code_to_string(code),
2440 "EXIT_STATUS=%i", status,
2441 NULL);
f42806df
LP		 2442
2443 if (f != SERVICE_SUCCESS)
2444 s->result = f;
034c6ed7 2445
867b3b7d
LP		 2446 if (s->main_command &&
2447 s->main_command->command_next &&
f42806df 2448 f == SERVICE_SUCCESS) {
034c6ed7 2449
34e9ba66
LP		 2450 /* There is another command to *
2451 * execute, so let's do that. */
034c6ed7 2452
79008bdd 2453 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
f42806df 2454 service_run_next_main(s);
034c6ed7 2455
34e9ba66
LP		 2456 } else {
2457
2458 /* The service exited, so the service is officially
2459 * gone. */
867b3b7d 2460 s->main_command = NULL;
34e9ba66
LP		 2461
2462 switch (s->state) {
2463
2464 case SERVICE_START_POST:
2465 case SERVICE_RELOAD:
2466 case SERVICE_STOP:
2467 /* Need to wait until the operation is
2468 * done */
c4653a4d 2469 break;
7d55e835 2470
34e9ba66
LP		 2471 case SERVICE_START:
2472 if (s->type == SERVICE_ONESHOT) {
2473 /* This was our main goal, so let's go on */
f42806df 2474 if (f == SERVICE_SUCCESS)
34e9ba66
LP		 2475 service_enter_start_post(s);
2476 else
f42806df 2477 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
34e9ba66 2478 break;
34e9ba66 2479 }
034c6ed7 2480
bfba3256
LP		 2481 /* Fall through */
2482
34e9ba66 2483 case SERVICE_RUNNING:
f42806df 2484 service_enter_running(s, f);
34e9ba66 2485 break;
034c6ed7 2486
db2cb23b 2487 case SERVICE_STOP_SIGABRT:
34e9ba66
LP		 2488 case SERVICE_STOP_SIGTERM:
2489 case SERVICE_STOP_SIGKILL:
5cb5a6ff 2490
34e9ba66 2491 if (!control_pid_good(s))
f42806df 2492 service_enter_stop_post(s, f);
5cb5a6ff 2493
34e9ba66
LP		 2494 /* If there is still a control process, wait for that first */
2495 break;
2496
bf108e55
LP		 2497 case SERVICE_STOP_POST:
2498 case SERVICE_FINAL_SIGTERM:
2499 case SERVICE_FINAL_SIGKILL:
2500
2501 if (!control_pid_good(s))
2502 service_enter_dead(s, f, true);
2503 break;
2504
34e9ba66
LP		 2505 default:
2506 assert_not_reached("Uh, main process died at wrong time.");
2507 }
034c6ed7 2508 }
5cb5a6ff 2509
034c6ed7 2510 } else if (s->control_pid == pid) {
34e9ba66
LP		 2511 s->control_pid = 0;
2512
b708e7ce 2513 if (s->control_command) {
8bb2d17d 2514 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
a16e1123 2515
b708e7ce 2516 if (s->control_command->ignore)
f42806df 2517 f = SERVICE_SUCCESS;
b708e7ce
LP		 2518 }
2519
79008bdd
LP		 2520 log_unit_full(u->id,
2521 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
66870f90
ZJS		 2522 "%s: control process exited, code=%s status=%i",
2523 u->id, sigchld_code_to_string(code), status);
f42806df
LP		 2524
2525 if (f != SERVICE_SUCCESS)
2526 s->result = f;
034c6ed7 2527
88f3e0c9
LP		 2528 /* Immediately get rid of the cgroup, so that the
2529 * kernel doesn't delay the cgroup empty messages for
2530 * the service cgroup any longer than necessary */
4ad49000 2531 service_kill_control_processes(s);
88f3e0c9 2532
34e9ba66
LP		 2533 if (s->control_command &&
2534 s->control_command->command_next &&
f42806df 2535 f == SERVICE_SUCCESS) {
034c6ed7
LP		 2536
2537 /* There is another command to *
2538 * execute, so let's do that. */
2539
79008bdd 2540 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
f42806df 2541 service_run_next_control(s);
034c6ed7 2542
80876c20 2543 } else {
034c6ed7
LP		 2544 /* No further commands for this step, so let's
2545 * figure out what to do next */
2546
a16e1123
LP		 2547 s->control_command = NULL;
2548 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2549
79008bdd 2550 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
bd982a8b 2551
034c6ed7
LP		 2552 switch (s->state) {
2553
2554 case SERVICE_START_PRE:
f42806df 2555 if (f == SERVICE_SUCCESS)
034c6ed7
LP		 2556 service_enter_start(s);
2557 else
f42806df 2558 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
034c6ed7
LP		 2559 break;
2560
2561 case SERVICE_START:
bfba3256
LP		 2562 if (s->type != SERVICE_FORKING)
2563 /* Maybe spurious event due to a reload that changed the type? */
2564 break;
034c6ed7 2565
f42806df
LP		 2566 if (f != SERVICE_SUCCESS) {
2567 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3a111838
MS		 2568 break;
2569 }
034c6ed7 2570
3a111838 2571 if (s->pid_file) {
f42806df
LP		 2572 bool has_start_post;
2573 int r;
2574
3a111838
MS		 2575 /* Let's try to load the pid file here if we can.
2576 * The PID file might actually be created by a START_POST
2577 * script. In that case don't worry if the loading fails. */
f42806df
LP		 2578
2579 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2580 r = service_load_pid_file(s, !has_start_post);
3a111838
MS		 2581 if (!has_start_post && r < 0) {
2582 r = service_demand_pid_file(s);
2583 if (r < 0 || !cgroup_good(s))
f42806df 2584 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 2585 break;
2586 }
034c6ed7 2587 } else
3a111838 2588 service_search_main_pid(s);
034c6ed7 2589
3a111838 2590 service_enter_start_post(s);
034c6ed7
LP		 2591 break;
2592
2593 case SERVICE_START_POST:
f42806df
LP		 2594 if (f != SERVICE_SUCCESS) {
2595 service_enter_stop(s, f);
2096e009 2596 break;
034c6ed7
LP		 2597 }
2598
2096e009 2599 if (s->pid_file) {
f42806df
LP		 2600 int r;
2601
2602 r = service_load_pid_file(s, true);
2096e009
MS		 2603 if (r < 0) {
2604 r = service_demand_pid_file(s);
2605 if (r < 0 || !cgroup_good(s))
f42806df 2606 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2096e009
MS		 2607 break;
2608 }
2609 } else
2610 service_search_main_pid(s);
2611
f42806df 2612 service_enter_running(s, SERVICE_SUCCESS);
3185a36b 2613 break;
034c6ed7
LP		 2614
2615 case SERVICE_RELOAD:
f42806df 2616 if (f == SERVICE_SUCCESS) {
5375410b 2617 service_load_pid_file(s, true);
3185a36b
LP		 2618 service_search_main_pid(s);
2619 }
2620
f42806df
LP		 2621 s->reload_result = f;
2622 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2623 break;
2624
2625 case SERVICE_STOP:
f42806df 2626 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
034c6ed7
LP		 2627 break;
2628
db2cb23b 2629 case SERVICE_STOP_SIGABRT:
034c6ed7
LP		 2630 case SERVICE_STOP_SIGTERM:
2631 case SERVICE_STOP_SIGKILL:
2632 if (main_pid_good(s) <= 0)
f42806df 2633 service_enter_stop_post(s, f);
034c6ed7
LP		 2634
2635 /* If there is still a service
2636 * process around, wait until
2637 * that one quit, too */
2638 break;
2639
2640 case SERVICE_STOP_POST:
2641 case SERVICE_FINAL_SIGTERM:
2642 case SERVICE_FINAL_SIGKILL:
bf108e55
LP		 2643 if (main_pid_good(s) <= 0)
2644 service_enter_dead(s, f, true);
034c6ed7
LP		 2645 break;
2646
2647 default:
2648 assert_not_reached("Uh, control process died at wrong time.");
2649 }
2650 }
8c47c732 2651 }
c4e2ceae
LP		 2652
2653 /* Notify clients about changed exit status */
2654 unit_add_to_dbus_queue(u);
a911bb9a
LP		 2655
2656 /* We got one SIGCHLD for the service, let's watch all
2657 * processes that are now running of the service, and watch
2658 * that. Among the PIDs we then watch will be children
2659 * reassigned to us, which hopefully allows us to identify
2660 * when all children are gone */
2661 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2662 unit_watch_all_pids(u);
2663
2664 /* If the PID set is empty now, then let's finish this off */
2665 if (set_isempty(u->pids))
2666 service_notify_cgroup_empty_event(u);
034c6ed7
LP		 2667}
2668
718db961
LP		 2669static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2670 Service *s = SERVICE(userdata);
034c6ed7
LP		 2671
2672 assert(s);
718db961 2673 assert(source == s->timer_event_source);
034c6ed7
LP		 2674
2675 switch (s->state) {
2676
2677 case SERVICE_START_PRE:
2678 case SERVICE_START:
79008bdd 2679 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
f42806df 2680 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
80876c20
LP		 2681 break;
2682
034c6ed7 2683 case SERVICE_START_POST:
79008bdd 2684 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
f42806df 2685 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 2686 break;
2687
e2f3b44c 2688 case SERVICE_RELOAD:
79008bdd 2689 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
f42806df
LP		 2690 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2691 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c
LP		 2692 break;
2693
034c6ed7 2694 case SERVICE_STOP:
79008bdd 2695 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
f42806df 2696 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 2697 break;
2698
db2cb23b 2699 case SERVICE_STOP_SIGABRT:
79008bdd 2700 log_unit_warning(UNIT(s)->id,
db2cb23b
UTL		 2701 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2702 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2703 break;
2704
034c6ed7 2705 case SERVICE_STOP_SIGTERM:
4819ff03 2706 if (s->kill_context.send_sigkill) {
79008bdd 2707 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
f42806df 2708 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 2709 } else {
79008bdd 2710 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
f42806df 2711 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
ba035df2
LP		 2712 }
2713
034c6ed7
LP		 2714 break;
2715
2716 case SERVICE_STOP_SIGKILL:
35b8ca3a 2717 /* Uh, we sent a SIGKILL and it is still not gone?
034c6ed7
LP		 2718 * Must be something we cannot kill, so let's just be
2719 * weirded out and continue */
2720
79008bdd 2721 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
f42806df 2722 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 2723 break;
2724
2725 case SERVICE_STOP_POST:
79008bdd 2726 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
f42806df 2727 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 2728 break;
2729
2730 case SERVICE_FINAL_SIGTERM:
4819ff03 2731 if (s->kill_context.send_sigkill) {
79008bdd 2732 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
f42806df 2733 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 2734 } else {
79008bdd 2735 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
f42806df 2736 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
ba035df2
LP		 2737 }
2738
034c6ed7
LP		 2739 break;
2740
2741 case SERVICE_FINAL_SIGKILL:
79008bdd 2742 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
f42806df 2743 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
034c6ed7
LP		 2744 break;
2745
2746 case SERVICE_AUTO_RESTART:
79008bdd 2747 log_unit_info(UNIT(s)->id,
ef417cfd
ZJS		 2748 s->restart_usec > 0 ?
2749 "%s holdoff time over, scheduling restart." :
2750 "%s has no holdoff time, scheduling restart.",
2751 UNIT(s)->id);
034c6ed7
LP		 2752 service_enter_restart(s);
2753 break;
2754
2755 default:
2756 assert_not_reached("Timeout at wrong time.");
2757 }
718db961
LP		 2758
2759 return 0;
2760}
2761
2762static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2763 Service *s = SERVICE(userdata);
a7850c7d 2764 char t[FORMAT_TIMESPAN_MAX];
718db961
LP		 2765
2766 assert(s);
2767 assert(source == s->watchdog_event_source);
2768
79008bdd 2769 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
a7850c7d 2770 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
8bb2d17d 2771
db2cb23b 2772 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
842129f5 2773
718db961 2774 return 0;
5cb5a6ff
LP		 2775}
2776
a354329f 2777static void service_notify_message(Unit *u, pid_t pid, char **tags, FDSet *fds) {
8c47c732 2778 Service *s = SERVICE(u);
308d72dc 2779 _cleanup_free_ char *cc = NULL;
30b5275a 2780 bool notify_dbus = false;
308d72dc 2781 const char *e;
8c47c732
LP		 2782
2783 assert(u);
2784
308d72dc 2785 cc = strv_join(tags, ", ");
79008bdd 2786 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
308d72dc 2787 u->id, pid, isempty(cc) ? "n/a" : cc);
da13d4d2 2788
c952c6ec 2789 if (s->notify_access == NOTIFY_NONE) {
79008bdd 2790 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
c952c6ec
LP		 2791 return;
2792 }
2793
336c6e46 2794 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
336c6e46 2795 if (s->main_pid != 0)
79008bdd 2796 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
336c6e46 2797 else
79008bdd 2798 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
c952c6ec
LP		 2799 return;
2800 }
2801
8c47c732 2802 /* Interpret MAINPID= */
28849dba 2803 e = strv_find_startswith(tags, "MAINPID=");
5e56b378 2804 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
28849dba 2805 if (parse_pid(e, &pid) < 0)
79008bdd 2806 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
8c47c732 2807 else {
79008bdd 2808 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
28849dba 2809
5925dd3c 2810 service_set_main_pid(s, pid);
7400b9d2 2811 unit_watch_pid(UNIT(s), pid);
30b5275a 2812 notify_dbus = true;
8c47c732
LP		 2813 }
2814 }
2815
308d72dc
LP		 2816 /* Interpret RELOADING= */
2817 if (strv_find(tags, "RELOADING=1")) {
2818
79008bdd 2819 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
308d72dc
LP		 2820 s->notify_state = NOTIFY_RELOADING;
2821
2822 if (s->state == SERVICE_RUNNING)
2823 service_enter_reload_by_notify(s);
2824
2825 notify_dbus = true;
2826 }
2827
8c47c732 2828 /* Interpret READY= */
308d72dc
LP		 2829 if (strv_find(tags, "READY=1")) {
2830
79008bdd 2831 log_unit_debug(u->id, "%s: got READY=1", u->id);
308d72dc
LP		 2832 s->notify_state = NOTIFY_READY;
2833
2834 /* Type=notify services inform us about completed
2835 * initialization with READY=1 */
2836 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2837 service_enter_start_post(s);
2838
2839 /* Sending READY=1 while we are reloading informs us
2840 * that the reloading is complete */
2841 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2842 service_enter_running(s, SERVICE_SUCCESS);
2843
2844 notify_dbus = true;
2845 }
2846
2847 /* Interpret STOPPING= */
2848 if (strv_find(tags, "STOPPING=1")) {
2849
79008bdd 2850 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
308d72dc
LP		 2851 s->notify_state = NOTIFY_STOPPING;
2852
2853 if (s->state == SERVICE_RUNNING)
2854 service_enter_stop_by_notify(s);
2855
30b5275a 2856 notify_dbus = true;
8c47c732
LP		 2857 }
2858
2859 /* Interpret STATUS= */
28849dba 2860 e = strv_find_startswith(tags, "STATUS=");
7f110ff9 2861 if (e) {
28849dba 2862 _cleanup_free_ char *t = NULL;
8c47c732 2863
28849dba
LP		 2864 if (!isempty(e)) {
2865 if (!utf8_is_valid(e))
79008bdd 2866 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
28849dba 2867 else {
79008bdd 2868 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
7f110ff9 2869
28849dba
LP		 2870 t = strdup(e);
2871 if (!t)
2872 log_oom();
3a2776bc 2873 }
28849dba 2874 }
8c47c732 2875
30b5275a 2876 if (!streq_ptr(s->status_text, t)) {
28849dba 2877
3a2776bc
LP		 2878 free(s->status_text);
2879 s->status_text = t;
28849dba
LP		 2880 t = NULL;
2881
30b5275a 2882 notify_dbus = true;
28849dba 2883 }
8c47c732 2884 }
842129f5 2885
4774e357 2886 /* Interpret ERRNO= */
28849dba 2887 e = strv_find_startswith(tags, "ERRNO=");
4774e357
MAA		 2888 if (e) {
2889 int status_errno;
2890
28849dba 2891 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
79008bdd 2892 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
4774e357 2893 else {
79008bdd 2894 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
4774e357
MAA		 2895
2896 if (s->status_errno != status_errno) {
2897 s->status_errno = status_errno;
2898 notify_dbus = true;
2899 }
2900 }
2901 }
2902
6f285378 2903 /* Interpret WATCHDOG= */
a6927d7f 2904 if (strv_find(tags, "WATCHDOG=1")) {
79008bdd 2905 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
842129f5 2906 service_reset_watchdog(s);
a6927d7f 2907 }
c4e2ceae 2908
a354329f
LP		 2909 /* Add the passed fds to the fd store */
2910 if (strv_find(tags, "FDSTORE=1")) {
2911 log_unit_debug(u->id, "%s: got FDSTORE=1", u->id);
2339fc93 2912 service_add_fd_store_set(s, fds);
a354329f
LP		 2913 }
2914
c4e2ceae 2915 /* Notify clients about changed status or main pid */
30b5275a
LP		 2916 if (notify_dbus)
2917 unit_add_to_dbus_queue(u);
8c47c732
LP		 2918}
2919
68db7a3b
ZJS		 2920static int service_get_timeout(Unit *u, uint64_t *timeout) {
2921 Service *s = SERVICE(u);
2922 int r;
2923
2924 if (!s->timer_event_source)
2925 return 0;
2926
2927 r = sd_event_source_get_time(s->timer_event_source, timeout);
2928 if (r < 0)
2929 return r;
2930
2931 return 1;
2932}
2933
05e343b7
LP		 2934static void service_bus_name_owner_change(
2935 Unit *u,
2936 const char *name,
2937 const char *old_owner,
2938 const char *new_owner) {
2939
2940 Service *s = SERVICE(u);
718db961 2941 int r;
05e343b7
LP		 2942
2943 assert(s);
2944 assert(name);
2945
2946 assert(streq(s->bus_name, name));
2947 assert(old_owner || new_owner);
2948
2949 if (old_owner && new_owner)
79008bdd 2950 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
05e343b7 2951 else if (old_owner)
79008bdd 2952 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
05e343b7 2953 else
79008bdd 2954 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
05e343b7
LP		 2955
2956 s->bus_name_good = !!new_owner;
2957
2958 if (s->type == SERVICE_DBUS) {
2959
2960 /* service_enter_running() will figure out what to
2961 * do */
2962 if (s->state == SERVICE_RUNNING)
f42806df 2963 service_enter_running(s, SERVICE_SUCCESS);
05e343b7
LP		 2964 else if (s->state == SERVICE_START && new_owner)
2965 service_enter_start_post(s);
2966
2967 } else if (new_owner &&
2968 s->main_pid <= 0 &&
2969 (s->state == SERVICE_START ||
2970 s->state == SERVICE_START_POST ||
2971 s->state == SERVICE_RUNNING ||
2972 s->state == SERVICE_RELOAD)) {
2973
5b12334d 2974 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
718db961 2975 pid_t pid;
05e343b7 2976
718db961 2977 /* Try to acquire PID from bus service */
05e343b7 2978
056f95d0 2979 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
5b12334d
LP		 2980 if (r >= 0)
2981 r = sd_bus_creds_get_pid(creds, &pid);
718db961 2982 if (r >= 0) {
79008bdd 2983 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
05e343b7 2984
718db961
LP		 2985 service_set_main_pid(s, pid);
2986 unit_watch_pid(UNIT(s), pid);
2987 }
7400b9d2 2988 }
05e343b7
LP		 2989}
2990
16115b0a 2991int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
79a98c60
LP		 2992 _cleanup_free_ char *peer = NULL;
2993 int r;
57020a3a 2994
4f2d528d
LP		 2995 assert(s);
2996 assert(fd >= 0);
2997
2998 /* This is called by the socket code when instantiating a new
2999 * service for a stream socket and the socket needs to be
3000 * configured. */
3001
1124fe6f 3002 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 3003 return -EINVAL;
3004
3005 if (s->socket_fd >= 0)
3006 return -EBUSY;
3007
3008 if (s->state != SERVICE_DEAD)
3009 return -EAGAIN;
3010
79a98c60
LP		 3011 if (getpeername_pretty(fd, &peer) >= 0) {
3012
3013 if (UNIT(s)->description) {
3014 _cleanup_free_ char *a;
3015
3016 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3017 if (!a)
3018 return -ENOMEM;
3019
3020 r = unit_set_description(UNIT(s), a);
3021 } else
3022 r = unit_set_description(UNIT(s), peer);
3023
3024 if (r < 0)
3025 return r;
3026 }
3027
4f2d528d 3028 s->socket_fd = fd;
16115b0a 3029 s->socket_fd_selinux_context_net = selinux_context_net;
6cf6bbc2 3030
57020a3a
LP		 3031 unit_ref_set(&s->accept_socket, UNIT(sock));
3032
3033 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
4f2d528d
LP		 3034}
3035
fdf20a31 3036static void service_reset_failed(Unit *u) {
5632e374
LP		 3037 Service *s = SERVICE(u);
3038
3039 assert(s);
3040
fdf20a31 3041 if (s->state == SERVICE_FAILED)
5632e374
LP		 3042 service_set_state(s, SERVICE_DEAD);
3043
f42806df
LP		 3044 s->result = SERVICE_SUCCESS;
3045 s->reload_result = SERVICE_SUCCESS;
451b34cc
LP		 3046
3047 RATELIMIT_RESET(s->start_limit);
5632e374
LP		 3048}
3049
718db961 3050static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
8a0867d6 3051 Service *s = SERVICE(u);
41efeaec 3052
814cc562 3053 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
8a0867d6
LP		 3054}
3055
94f04347
LP		 3056static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3057 [SERVICE_DEAD] = "dead",
3058 [SERVICE_START_PRE] = "start-pre",
3059 [SERVICE_START] = "start",
3060 [SERVICE_START_POST] = "start-post",
3061 [SERVICE_RUNNING] = "running",
80876c20 3062 [SERVICE_EXITED] = "exited",
94f04347
LP		 3063 [SERVICE_RELOAD] = "reload",
3064 [SERVICE_STOP] = "stop",
1378a3b5 3065 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
94f04347
LP		 3066 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3067 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3068 [SERVICE_STOP_POST] = "stop-post",
3069 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3070 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 3071 [SERVICE_FAILED] = "failed",
94f04347
LP		 3072 [SERVICE_AUTO_RESTART] = "auto-restart",
3073};
3074
3075DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3076
3077static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
525ee6f4
LP		 3078 [SERVICE_RESTART_NO] = "no",
3079 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
50caaedb 3080 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
6cfe2fde 3081 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
dc99a976 3082 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
50caaedb 3083 [SERVICE_RESTART_ON_ABORT] = "on-abort",
6cfe2fde 3084 [SERVICE_RESTART_ALWAYS] = "always",
94f04347
LP		 3085};
3086
3087DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3088
3089static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
94f04347 3090 [SERVICE_SIMPLE] = "simple",
0d624a78 3091 [SERVICE_FORKING] = "forking",
34e9ba66 3092 [SERVICE_ONESHOT] = "oneshot",
8c47c732 3093 [SERVICE_DBUS] = "dbus",
f2b68789
LP		 3094 [SERVICE_NOTIFY] = "notify",
3095 [SERVICE_IDLE] = "idle"
94f04347
LP		 3096};
3097
3098DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3099
e537352b 3100static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
94f04347
LP		 3101 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3102 [SERVICE_EXEC_START] = "ExecStart",
3103 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3104 [SERVICE_EXEC_RELOAD] = "ExecReload",
3105 [SERVICE_EXEC_STOP] = "ExecStop",
3106 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3107};
3108
3109DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3110
c952c6ec
LP		 3111static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3112 [NOTIFY_NONE] = "none",
3113 [NOTIFY_MAIN] = "main",
3114 [NOTIFY_ALL] = "all"
3115};
3116
3117DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3118
308d72dc
LP		 3119static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3120 [NOTIFY_UNKNOWN] = "unknown",
3121 [NOTIFY_READY] = "ready",
3122 [NOTIFY_RELOADING] = "reloading",
3123 [NOTIFY_STOPPING] = "stopping",
3124};
3125
3126DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3127
f42806df
LP		 3128static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3129 [SERVICE_SUCCESS] = "success",
3130 [SERVICE_FAILURE_RESOURCES] = "resources",
3131 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3132 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3133 [SERVICE_FAILURE_SIGNAL] = "signal",
bb242b7b 3134 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
8d1b002a
LP		 3135 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3136 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
f42806df
LP		 3137};
3138
3139DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3140
87f0e418 3141const UnitVTable service_vtable = {
7d17cfbc 3142 .object_size = sizeof(Service),
718db961
LP		 3143 .exec_context_offset = offsetof(Service, exec_context),
3144 .cgroup_context_offset = offsetof(Service, cgroup_context),
3145 .kill_context_offset = offsetof(Service, kill_context),
613b411c 3146 .exec_runtime_offset = offsetof(Service, exec_runtime),
3ef63c31 3147
f975e971
LP		 3148 .sections =
3149 "Unit\0"
3150 "Service\0"
3151 "Install\0",
4ad49000 3152 .private_section = "Service",
71645aca 3153
034c6ed7
LP		 3154 .init = service_init,
3155 .done = service_done,
a16e1123 3156 .load = service_load,
a354329f 3157 .release_resources = service_release_resources,
a16e1123
LP		 3158
3159 .coldplug = service_coldplug,
034c6ed7 3160
5cb5a6ff
LP		 3161 .dump = service_dump,
3162
3163 .start = service_start,
3164 .stop = service_stop,
3165 .reload = service_reload,
3166
034c6ed7
LP		 3167 .can_reload = service_can_reload,
3168
8a0867d6
LP		 3169 .kill = service_kill,
3170
a16e1123
LP		 3171 .serialize = service_serialize,
3172 .deserialize_item = service_deserialize_item,
3173
5cb5a6ff 3174 .active_state = service_active_state,
10a94420 3175 .sub_state_to_string = service_sub_state_to_string,
5cb5a6ff 3176
701cc384
LP		 3177 .check_gc = service_check_gc,
3178 .check_snapshot = service_check_snapshot,
3179
034c6ed7 3180 .sigchld_event = service_sigchld_event,
2c4104f0 3181
fdf20a31 3182 .reset_failed = service_reset_failed,
5632e374 3183
4ad49000 3184 .notify_cgroup_empty = service_notify_cgroup_empty_event,
8c47c732 3185 .notify_message = service_notify_message,
8e274523 3186
05e343b7 3187 .bus_name_owner_change = service_bus_name_owner_change,
05e343b7 3188
c4e2ceae 3189 .bus_interface = "org.freedesktop.systemd1.Service",
718db961 3190 .bus_vtable = bus_service_vtable,
74c964d3
LP		 3191 .bus_set_property = bus_service_set_property,
3192 .bus_commit_properties = bus_service_commit_properties,
4139c1b2 3193
68db7a3b 3194 .get_timeout = service_get_timeout,
718db961
LP		 3195 .can_transient = true,
3196
c6918296
MS		 3197 .status_message_formats = {
3198 .starting_stopping = {
3199 [0] = "Starting %s...",
3200 [1] = "Stopping %s...",
3201 },
3202 .finished_start_job = {
3203 [JOB_DONE] = "Started %s.",
3204 [JOB_FAILED] = "Failed to start %s.",
3205 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3206 [JOB_TIMEOUT] = "Timed out starting %s.",
3207 },
3208 .finished_stop_job = {
3209 [JOB_DONE] = "Stopped %s.",
3210 [JOB_FAILED] = "Stopped (with error) %s.",
3211 [JOB_TIMEOUT] = "Timed out stopping %s.",
3212 },
3213 },
5cb5a6ff 3214};
Unnamed repository; edit this file 'description' to name the repository.