]> 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
util.c: ignore pollfd.revent for loop_read/loop_write
[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
LP		 24#include <dirent.h>
25#include <unistd.h>
4b939747 26#include <sys/reboot.h>
5cb5a6ff 27
4b939747 28#include "manager.h"
87f0e418 29#include "unit.h"
5cb5a6ff
LP		 30#include "service.h"
31#include "load-fragment.h"
32#include "load-dropin.h"
034c6ed7 33#include "log.h"
2c4104f0 34#include "strv.h"
9e2f7c11 35#include "unit-name.h"
41f9172f 36#include "unit-printf.h"
4139c1b2 37#include "dbus-service.h"
514f4ef5 38#include "special.h"
449101fc 39#include "dbus-common.h"
9a57c629 40#include "exit-status.h"
f6a6225e 41#include "def.h"
9eb977db 42#include "path-util.h"
f6a6225e 43#include "util.h"
7f110ff9 44#include "utf8.h"
4d1a6904 45#include "env-util.h"
a5c32cff 46#include "fileio.h"
034c6ed7 47
07459bb6 48#ifdef HAVE_SYSV_COMPAT
f34277d9 49
f6a6225e 50#define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
f34277d9 51
09cd1ab1
LP		 52typedef enum RunlevelType {
53 RUNLEVEL_UP,
3cdebc21 54 RUNLEVEL_DOWN
09cd1ab1
LP		 55} RunlevelType;
56
57static const struct {
58 const char *path;
59 const char *target;
60 const RunlevelType type;
61} rcnd_table[] = {
9d25f5ed 62 /* Standard SysV runlevels for start-up */
514f4ef5 63 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
fbe9f3a9
LP		 64 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
65 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
66 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
67 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
fbe9f3a9 68
9d25f5ed
LP		 69 /* Standard SysV runlevels for shutdown */
70 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
71 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
72
73 /* Note that the order here matters, as we read the
74 directories in this order, and we want to make sure that
75 sysv_start_priority is known when we first load the
76 unit. And that value we only know from S links. Hence
3cdebc21 77 UP must be read before DOWN */
23a177ef
LP		 78};
79
09cd1ab1 80#define RUNLEVELS_UP "12345"
07459bb6 81#endif
09cd1ab1 82
acbb0225 83static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
87f0e418
LP		 84 [SERVICE_DEAD] = UNIT_INACTIVE,
85 [SERVICE_START_PRE] = UNIT_ACTIVATING,
86 [SERVICE_START] = UNIT_ACTIVATING,
87 [SERVICE_START_POST] = UNIT_ACTIVATING,
88 [SERVICE_RUNNING] = UNIT_ACTIVE,
80876c20 89 [SERVICE_EXITED] = UNIT_ACTIVE,
032ff4af 90 [SERVICE_RELOAD] = UNIT_RELOADING,
87f0e418
LP		 91 [SERVICE_STOP] = UNIT_DEACTIVATING,
92 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
93 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
94 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
95 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
96 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
fdf20a31 97 [SERVICE_FAILED] = UNIT_FAILED,
6124958c 98 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
034c6ed7 99};
5cb5a6ff 100
e056b01d
LP		 101/* For Type=idle we never want to delay any other jobs, hence we
102 * consider idle jobs active as soon as we start working on them */
103static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
104 [SERVICE_DEAD] = UNIT_INACTIVE,
105 [SERVICE_START_PRE] = UNIT_ACTIVE,
106 [SERVICE_START] = UNIT_ACTIVE,
107 [SERVICE_START_POST] = UNIT_ACTIVE,
108 [SERVICE_RUNNING] = UNIT_ACTIVE,
109 [SERVICE_EXITED] = UNIT_ACTIVE,
110 [SERVICE_RELOAD] = UNIT_RELOADING,
111 [SERVICE_STOP] = UNIT_DEACTIVATING,
112 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
113 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
114 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
115 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
116 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
117 [SERVICE_FAILED] = UNIT_FAILED,
118 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
119};
120
a16e1123
LP		 121static void service_init(Unit *u) {
122 Service *s = SERVICE(u);
123
124 assert(u);
ac155bb8 125 assert(u->load_state == UNIT_STUB);
a16e1123 126
d568a335
MS		 127 s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
128 s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
a16e1123 129 s->restart_usec = DEFAULT_RESTART_USEC;
0b86feac 130 s->type = _SERVICE_TYPE_INVALID;
bb242b7b 131
68b29a9f
LP		 132 watch_init(&s->watchdog_watch);
133 watch_init(&s->timer_watch);
bb242b7b 134
07459bb6 135#ifdef HAVE_SYSV_COMPAT
a16e1123 136 s->sysv_start_priority = -1;
ea87ca5a 137 s->sysv_start_priority_from_rcnd = -1;
07459bb6 138#endif
a16e1123 139 s->socket_fd = -1;
3185a36b 140 s->guess_main_pid = true;
a16e1123
LP		 141
142 exec_context_init(&s->exec_context);
4819ff03 143 kill_context_init(&s->kill_context);
4ad49000 144 cgroup_context_init(&s->cgroup_context);
a16e1123 145
4b939747 146 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
a16e1123
LP		 147
148 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
149}
150
5e94833f
LP		 151static void service_unwatch_control_pid(Service *s) {
152 assert(s);
153
154 if (s->control_pid <= 0)
155 return;
156
157 unit_unwatch_pid(UNIT(s), s->control_pid);
158 s->control_pid = 0;
159}
160
161static void service_unwatch_main_pid(Service *s) {
162 assert(s);
163
164 if (s->main_pid <= 0)
165 return;
166
167 unit_unwatch_pid(UNIT(s), s->main_pid);
168 s->main_pid = 0;
169}
170
3e52541e
MS		 171static void service_unwatch_pid_file(Service *s) {
172 if (!s->pid_file_pathspec)
173 return;
174
66870f90
ZJS		 175 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
176 UNIT(s)->id, s->pid_file_pathspec->path);
3e52541e
MS		 177 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
178 path_spec_done(s->pid_file_pathspec);
179 free(s->pid_file_pathspec);
180 s->pid_file_pathspec = NULL;
181}
182
5925dd3c 183static int service_set_main_pid(Service *s, pid_t pid) {
e55224ca
LP		 184 pid_t ppid;
185
5925dd3c
LP		 186 assert(s);
187
188 if (pid <= 1)
189 return -EINVAL;
190
191 if (pid == getpid())
192 return -EINVAL;
193
41efeaec
LP		 194 service_unwatch_main_pid(s);
195
6dfa5494
LP		 196 s->main_pid = pid;
197 s->main_pid_known = true;
198
199 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
66870f90
ZJS		 200 log_warning_unit(UNIT(s)->id,
201 "%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
202 UNIT(s)->id, (unsigned long) pid);
e55224ca 203
6dfa5494
LP		 204 s->main_pid_alien = true;
205 } else
206 s->main_pid_alien = false;
5925dd3c 207
b58b4116
LP		 208 exec_status_start(&s->main_exec_status, pid);
209
5925dd3c
LP		 210 return 0;
211}
212
4f2d528d
LP		 213static void service_close_socket_fd(Service *s) {
214 assert(s);
215
216 if (s->socket_fd < 0)
217 return;
218
219 close_nointr_nofail(s->socket_fd);
220 s->socket_fd = -1;
221}
222
6cf6bbc2
LP		 223static void service_connection_unref(Service *s) {
224 assert(s);
225
9444b1f2 226 if (!UNIT_ISSET(s->accept_socket))
6cf6bbc2
LP		 227 return;
228
57020a3a
LP		 229 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
230 unit_ref_unset(&s->accept_socket);
6cf6bbc2
LP		 231}
232
a6927d7f
MO		 233static void service_stop_watchdog(Service *s) {
234 assert(s);
235
bb242b7b 236 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
a6927d7f
MO		 237 s->watchdog_timestamp.realtime = 0;
238 s->watchdog_timestamp.monotonic = 0;
239}
240
9e9c3abc 241static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
bb242b7b
MO		 242
243static void service_handle_watchdog(Service *s) {
244 usec_t offset;
245 int r;
246
247 assert(s);
248
249 if (s->watchdog_usec == 0)
250 return;
251
252 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
253 if (offset >= s->watchdog_usec) {
66870f90 254 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
af471339 255 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_WATCHDOG);
bb242b7b
MO		 256 return;
257 }
258
36697dc0 259 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->watchdog_usec - offset, &s->watchdog_watch);
bb242b7b 260 if (r < 0)
66870f90
ZJS		 261 log_warning_unit(UNIT(s)->id,
262 "%s failed to install watchdog timer: %s",
263 UNIT(s)->id, strerror(-r));
bb242b7b
MO		 264}
265
a6927d7f
MO		 266static void service_reset_watchdog(Service *s) {
267 assert(s);
268
269 dual_timestamp_get(&s->watchdog_timestamp);
bb242b7b 270 service_handle_watchdog(s);
a6927d7f
MO		 271}
272
87f0e418
LP		 273static void service_done(Unit *u) {
274 Service *s = SERVICE(u);
44d8db9e
LP		 275
276 assert(s);
277
278 free(s->pid_file);
279 s->pid_file = NULL;
280
07459bb6 281#ifdef HAVE_SYSV_COMPAT
8309400a
LP		 282 free(s->sysv_runlevels);
283 s->sysv_runlevels = NULL;
07459bb6 284#endif
8309400a 285
8c47c732
LP		 286 free(s->status_text);
287 s->status_text = NULL;
288
4ad49000 289 cgroup_context_done(&s->cgroup_context);
c17ec25e 290 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
e537352b 291 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
44d8db9e 292 s->control_command = NULL;
867b3b7d 293 s->main_command = NULL;
44d8db9e 294
96342de6
LN		 295 set_free(s->restart_ignore_status.code);
296 s->restart_ignore_status.code = NULL;
297 set_free(s->restart_ignore_status.signal);
298 s->restart_ignore_status.signal = NULL;
299
300 set_free(s->success_status.code);
301 s->success_status.code = NULL;
302 set_free(s->success_status.signal);
303 s->success_status.signal = NULL;
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
4f2d528d 317 service_close_socket_fd(s);
6cf6bbc2 318 service_connection_unref(s);
4f2d528d 319
57020a3a 320 unit_ref_unset(&s->accept_socket);
f976f3f6 321
bb242b7b
MO		 322 service_stop_watchdog(s);
323
acbb0225 324 unit_unwatch_timer(u, &s->timer_watch);
44d8db9e
LP		 325}
326
07459bb6 327#ifdef HAVE_SYSV_COMPAT
b7ccee3c
LP		 328static char *sysv_translate_name(const char *name) {
329 char *r;
330
5d4caf56
LP		 331 r = new(char, strlen(name) + sizeof(".service"));
332 if (!r)
b7ccee3c
LP		 333 return NULL;
334
5b819198 335 if (endswith(name, ".sh"))
85a3fa0e 336 /* Drop .sh suffix */
5b819198 337 strcpy(stpcpy(r, name) - 3, ".service");
b7ccee3c 338 else
85a3fa0e 339 /* Normal init script name */
b7ccee3c
LP		 340 strcpy(stpcpy(r, name), ".service");
341
342 return r;
343}
344
ee95669f 345static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
2c4104f0 346
a7d3cc26
LP		 347 /* We silently ignore the $ prefix here. According to the LSB
348 * spec it simply indicates whether something is a
349 * standardized name or a distribution-specific one. Since we
350 * just follow what already exists and do not introduce new
351 * uses or names we don't care who introduced a new name. */
352
2c4104f0 353 static const char * const table[] = {
6464aa08 354 /* LSB defined facilities */
5d4caf56 355 "local_fs", NULL,
a7d3cc26
LP		 356 "network", SPECIAL_NETWORK_TARGET,
357 "named", SPECIAL_NSS_LOOKUP_TARGET,
358 "portmap", SPECIAL_RPCBIND_TARGET,
359 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
5d4caf56 360 "syslog", NULL,
4466194c 361 "time", SPECIAL_TIME_SYNC_TARGET,
2c4104f0
LP		 362 };
363
364 unsigned i;
365 char *r;
ee95669f 366 const char *n;
2c4104f0 367
ee95669f
LP		 368 assert(name);
369 assert(_r);
a7d3cc26 370
ee95669f 371 n = *name == '$' ? name + 1 : name;
a7d3cc26 372
ee95669f 373 for (i = 0; i < ELEMENTSOF(table); i += 2) {
a7d3cc26 374
ee95669f
LP		 375 if (!streq(table[i], n))
376 continue;
2c4104f0 377
ee95669f
LP		 378 if (!table[i+1])
379 return 0;
380
5d4caf56
LP		 381 r = strdup(table[i+1]);
382 if (!r)
383 return log_oom();
ee95669f
LP		 384
385 goto finish;
386 }
2c4104f0 387
a7d3cc26 388 /* If we don't know this name, fallback heuristics to figure
0003d1ab 389 * out whether something is a target or a service alias. */
a7d3cc26 390
e83c7c0b
LP		 391 if (*name == '$') {
392 if (!unit_prefix_is_valid(n))
393 return -EINVAL;
394
ee95669f
LP		 395 /* Facilities starting with $ are most likely targets */
396 r = unit_name_build(n, NULL, ".target");
e83c7c0b 397 } else if (filename && streq(name, filename))
35b8ca3a 398 /* Names equaling the file name of the services are redundant */
ee95669f 399 return 0;
32159d3a 400 else
ee95669f
LP		 401 /* Everything else we assume to be normal service names */
402 r = sysv_translate_name(n);
2c4104f0 403
32159d3a 404 if (!r)
2c4104f0
LP		 405 return -ENOMEM;
406
407finish:
b4353094 408 *_r = r;
2c4104f0
LP		 409
410 return 1;
411}
412
56d748b4 413static int sysv_fix_order(Service *s) {
ac155bb8 414 Unit *other;
2c4104f0
LP		 415 int r;
416
417 assert(s);
418
419 if (s->sysv_start_priority < 0)
420 return 0;
421
23a177ef
LP		 422 /* For each pair of services where at least one lacks a LSB
423 * header, we use the start priority value to order things. */
2c4104f0 424
1124fe6f 425 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
2c4104f0
LP		 426 Service *t;
427 UnitDependency d;
eeaafddc 428 bool special_s, special_t;
2c4104f0 429
595ed347 430 t = SERVICE(other);
2c4104f0
LP		 431
432 if (s == t)
433 continue;
9f151f29 434
1124fe6f 435 if (UNIT(t)->load_state != UNIT_LOADED)
9f151f29 436 continue;
2c4104f0
LP		 437
438 if (t->sysv_start_priority < 0)
439 continue;
440
51a1a79d
LP		 441 /* If both units have modern headers we don't care
442 * about the priorities */
1124fe6f
MS		 443 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
444 (UNIT(t)->fragment_path || t->sysv_has_lsb))
23a177ef
LP		 445 continue;
446
eeaafddc
LP		 447 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
448 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
449
450 if (special_t && !special_s)
451 d = UNIT_AFTER;
452 else if (special_s && !special_t)
453 d = UNIT_BEFORE;
454 else if (t->sysv_start_priority < s->sysv_start_priority)
2c4104f0
LP		 455 d = UNIT_AFTER;
456 else if (t->sysv_start_priority > s->sysv_start_priority)
457 d = UNIT_BEFORE;
458 else
459 continue;
460
461 /* FIXME: Maybe we should compare the name here lexicographically? */
462
da19d5c1 463 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
2c4104f0
LP		 464 return r;
465 }
466
467 return 0;
468}
469
470static ExecCommand *exec_command_new(const char *path, const char *arg1) {
471 ExecCommand *c;
472
473 if (!(c = new0(ExecCommand, 1)))
474 return NULL;
475
476 if (!(c->path = strdup(path))) {
477 free(c);
478 return NULL;
479 }
480
481 if (!(c->argv = strv_new(path, arg1, NULL))) {
482 free(c->path);
483 free(c);
484 return NULL;
485 }
486
487 return c;
488}
489
37e2941d 490static int sysv_exec_commands(Service *s, const bool supports_reload) {
2c4104f0
LP		 491 ExecCommand *c;
492
493 assert(s);
1b64d026
LP		 494 assert(s->is_sysv);
495 assert(UNIT(s)->source_path);
2c4104f0 496
1b64d026
LP		 497 c = exec_command_new(UNIT(s)->source_path, "start");
498 if (!c)
2c4104f0
LP		 499 return -ENOMEM;
500 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
501
1b64d026
LP		 502 c = exec_command_new(UNIT(s)->source_path, "stop");
503 if (!c)
2c4104f0
LP		 504 return -ENOMEM;
505 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
506
37e2941d
MS		 507 if (supports_reload) {
508 c = exec_command_new(UNIT(s)->source_path, "reload");
509 if (!c)
510 return -ENOMEM;
511 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
512 }
2c4104f0
LP		 513
514 return 0;
515}
516
37e2941d
MS		 517static bool usage_contains_reload(const char *line) {
518 return (strcasestr(line, "{reload|") ||
519 strcasestr(line, "{reload}") ||
520 strcasestr(line, "{reload\"") ||
521 strcasestr(line, "|reload|") ||
522 strcasestr(line, "|reload}") ||
523 strcasestr(line, "|reload\""));
524}
525
e537352b 526static int service_load_sysv_path(Service *s, const char *path) {
2c4104f0
LP		 527 FILE *f;
528 Unit *u;
529 unsigned line = 0;
530 int r;
531 enum {
532 NORMAL,
533 DESCRIPTION,
534 LSB,
37e2941d
MS		 535 LSB_DESCRIPTION,
536 USAGE_CONTINUATION
2c4104f0 537 } state = NORMAL;
0b5d26f9 538 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
5f4b19f4 539 struct stat st;
37e2941d 540 bool supports_reload = false;
23a177ef
LP		 541
542 assert(s);
543 assert(path);
2c4104f0
LP		 544
545 u = UNIT(s);
546
1b64d026
LP		 547 f = fopen(path, "re");
548 if (!f) {
2c4104f0
LP		 549 r = errno == ENOENT ? 0 : -errno;
550 goto finish;
551 }
552
5f4b19f4
LP		 553 if (fstat(fileno(f), &st) < 0) {
554 r = -errno;
555 goto finish;
556 }
557
1b64d026
LP		 558 free(u->source_path);
559 u->source_path = strdup(path);
560 if (!u->source_path) {
2c4104f0
LP		 561 r = -ENOMEM;
562 goto finish;
563 }
1b64d026 564 u->source_mtime = timespec_load(&st.st_mtim);
5f4b19f4
LP		 565
566 if (null_or_empty(&st)) {
ac155bb8 567 u->load_state = UNIT_MASKED;
5f4b19f4
LP		 568 r = 0;
569 goto finish;
570 }
571
1b64d026
LP		 572 s->is_sysv = true;
573
2c4104f0
LP		 574 while (!feof(f)) {
575 char l[LINE_MAX], *t;
576
577 if (!fgets(l, sizeof(l), f)) {
578 if (feof(f))
579 break;
580
581 r = -errno;
66870f90
ZJS		 582 log_error_unit(u->id,
583 "Failed to read configuration file '%s': %s",
584 path, strerror(-r));
2c4104f0
LP		 585 goto finish;
586 }
587
588 line++;
589
590 t = strstrip(l);
37e2941d
MS		 591 if (*t != '#') {
592 /* Try to figure out whether this init script supports
593 * the reload operation. This heuristic looks for
594 * "Usage" lines which include the reload option. */
595 if ( state == USAGE_CONTINUATION ||
596 (state == NORMAL && strcasestr(t, "usage"))) {
597 if (usage_contains_reload(t)) {
598 supports_reload = true;
599 state = NORMAL;
600 } else if (t[strlen(t)-1] == '\\')
601 state = USAGE_CONTINUATION;
602 else
603 state = NORMAL;
604 }
605
2c4104f0 606 continue;
37e2941d 607 }
2c4104f0
LP		 608
609 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
610 state = LSB;
23a177ef 611 s->sysv_has_lsb = true;
2c4104f0
LP		 612 continue;
613 }
614
615 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
616 state = NORMAL;
617 continue;
618 }
619
620 t++;
621 t += strspn(t, WHITESPACE);
622
623 if (state == NORMAL) {
624
625 /* Try to parse Red Hat style chkconfig headers */
626
c2b35af6 627 if (startswith_no_case(t, "chkconfig:")) {
2c4104f0 628 int start_priority;
8309400a 629 char runlevels[16], *k;
2c4104f0
LP		 630
631 state = NORMAL;
632
8309400a
LP		 633 if (sscanf(t+10, "%15s %i %*i",
634 runlevels,
635 &start_priority) != 2) {
2c4104f0 636
66870f90
ZJS		 637 log_warning_unit(u->id,
638 "[%s:%u] Failed to parse chkconfig line. Ignoring.",
639 path, line);
2c4104f0
LP		 640 continue;
641 }
642
fbe9f3a9
LP		 643 /* A start priority gathered from the
644 * symlink farms is preferred over the
645 * data from the LSB header. */
8309400a 646 if (start_priority < 0 || start_priority > 99)
66870f90
ZJS		 647 log_warning_unit(u->id,
648 "[%s:%u] Start priority out of range. Ignoring.",
649 path, line);
ea87ca5a 650 else
8309400a
LP		 651 s->sysv_start_priority = start_priority;
652
653 char_array_0(runlevels);
654 k = delete_chars(runlevels, WHITESPACE "-");
655
656 if (k[0]) {
657 char *d;
658
659 if (!(d = strdup(k))) {
660 r = -ENOMEM;
661 goto finish;
662 }
663
664 free(s->sysv_runlevels);
665 s->sysv_runlevels = d;
2c4104f0
LP		 666 }
667
0b5d26f9 668 } else if (startswith_no_case(t, "description:")) {
2c4104f0
LP		 669
670 size_t k = strlen(t);
671 char *d;
0b5d26f9 672 const char *j;
2c4104f0
LP		 673
674 if (t[k-1] == '\\') {
675 state = DESCRIPTION;
676 t[k-1] = 0;
677 }
678
0b5d26f9
LP		 679 if ((j = strstrip(t+12)) && *j) {
680 if (!(d = strdup(j))) {
681 r = -ENOMEM;
682 goto finish;
683 }
684 } else
685 d = NULL;
2c4104f0 686
0b5d26f9
LP		 687 free(chkconfig_description);
688 chkconfig_description = d;
2c4104f0 689
c2b35af6 690 } else if (startswith_no_case(t, "pidfile:")) {
2c4104f0
LP		 691
692 char *fn;
693
694 state = NORMAL;
695
696 fn = strstrip(t+8);
697 if (!path_is_absolute(fn)) {
66870f90
ZJS		 698 log_warning_unit(u->id,
699 "[%s:%u] PID file not absolute. Ignoring.",
700 path, line);
2c4104f0
LP		 701 continue;
702 }
703
704 if (!(fn = strdup(fn))) {
705 r = -ENOMEM;
706 goto finish;
707 }
708
709 free(s->pid_file);
710 s->pid_file = fn;
711 }
712
713 } else if (state == DESCRIPTION) {
714
715 /* Try to parse Red Hat style description
716 * continuation */
717
718 size_t k = strlen(t);
0b5d26f9 719 char *j;
2c4104f0
LP		 720
721 if (t[k-1] == '\\')
722 t[k-1] = 0;
723 else
724 state = NORMAL;
725
0b5d26f9
LP		 726 if ((j = strstrip(t)) && *j) {
727 char *d = NULL;
728
729 if (chkconfig_description)
b7def684 730 d = strjoin(chkconfig_description, " ", j, NULL);
0b5d26f9
LP		 731 else
732 d = strdup(j);
2c4104f0 733
0b5d26f9
LP		 734 if (!d) {
735 r = -ENOMEM;
736 goto finish;
737 }
738
739 free(chkconfig_description);
740 chkconfig_description = d;
741 }
2c4104f0
LP		 742
743 } else if (state == LSB || state == LSB_DESCRIPTION) {
744
c2b35af6 745 if (startswith_no_case(t, "Provides:")) {
2c4104f0
LP		 746 char *i, *w;
747 size_t z;
748
749 state = LSB;
750
f60f22df 751 FOREACH_WORD_QUOTED(w, z, t+9, i) {
2c4104f0
LP		 752 char *n, *m;
753
754 if (!(n = strndup(w, z))) {
755 r = -ENOMEM;
756 goto finish;
757 }
758
9eb977db 759 r = sysv_translate_facility(n, path_get_file_name(path), &m);
2c4104f0
LP		 760 free(n);
761
762 if (r < 0)
763 goto finish;
764
765 if (r == 0)
766 continue;
767
bd77d0fc 768 if (unit_name_to_type(m) == UNIT_SERVICE)
ce2c2265 769 r = unit_merge_by_name(u, m);
9700edb4
LP		 770 else
771 /* NB: SysV targets
772 * which are provided
773 * by a service are
774 * pulled in by the
775 * services, as an
776 * indication that the
777 * generic service is
778 * now available. This
779 * is strictly
780 * one-way. The
781 * targets do NOT pull
782 * in the SysV
783 * services! */
784 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
bd77d0fc 785
2c4104f0 786 if (r < 0)
66870f90
ZJS		 787 log_error_unit(u->id,
788 "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
789 path, line, m, strerror(-r));
42a097a2
LP		 790
791 free(m);
2c4104f0
LP		 792 }
793
c2b35af6
LP		 794 } else if (startswith_no_case(t, "Required-Start:") ||
795 startswith_no_case(t, "Should-Start:") ||
796 startswith_no_case(t, "X-Start-Before:") ||
797 startswith_no_case(t, "X-Start-After:")) {
2c4104f0
LP		 798 char *i, *w;
799 size_t z;
800
801 state = LSB;
802
f60f22df 803 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
2c4104f0
LP		 804 char *n, *m;
805
806 if (!(n = strndup(w, z))) {
807 r = -ENOMEM;
808 goto finish;
809 }
810
9eb977db 811 r = sysv_translate_facility(n, path_get_file_name(path), &m);
e83c7c0b 812 if (r < 0) {
66870f90
ZJS		 813 log_error_unit(u->id,
814 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
815 path, line, n, strerror(-r));
e83c7c0b
LP		 816 free(n);
817 continue;
818 }
819
820 free(n);
2c4104f0
LP		 821
822 if (r == 0)
823 continue;
824
c2b35af6 825 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
2c4104f0
LP		 826
827 if (r < 0)
66870f90
ZJS		 828 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
829 path, line, m, strerror(-r));
42a097a2
LP		 830
831 free(m);
2c4104f0 832 }
c2b35af6 833 } else if (startswith_no_case(t, "Default-Start:")) {
8309400a
LP		 834 char *k, *d;
835
836 state = LSB;
837
838 k = delete_chars(t+14, WHITESPACE "-");
839
840 if (k[0] != 0) {
841 if (!(d = strdup(k))) {
842 r = -ENOMEM;
843 goto finish;
844 }
845
846 free(s->sysv_runlevels);
847 s->sysv_runlevels = d;
848 }
2c4104f0 849
0b5d26f9
LP		 850 } else if (startswith_no_case(t, "Description:")) {
851 char *d, *j;
ed4c1cc6 852
2c4104f0
LP		 853 state = LSB_DESCRIPTION;
854
0b5d26f9
LP		 855 if ((j = strstrip(t+12)) && *j) {
856 if (!(d = strdup(j))) {
857 r = -ENOMEM;
858 goto finish;
859 }
860 } else
861 d = NULL;
2c4104f0 862
0b5d26f9
LP		 863 free(long_description);
864 long_description = d;
2c4104f0 865
ed4c1cc6 866 } else if (startswith_no_case(t, "Short-Description:")) {
0b5d26f9 867 char *d, *j;
2c4104f0 868
2c4104f0
LP		 869 state = LSB;
870
0b5d26f9
LP		 871 if ((j = strstrip(t+18)) && *j) {
872 if (!(d = strdup(j))) {
873 r = -ENOMEM;
874 goto finish;
875 }
876 } else
877 d = NULL;
2c4104f0 878
0b5d26f9
LP		 879 free(short_description);
880 short_description = d;
2c4104f0
LP		 881
882 } else if (state == LSB_DESCRIPTION) {
883
884 if (startswith(l, "#\t") || startswith(l, "# ")) {
0b5d26f9 885 char *j;
2c4104f0 886
0b5d26f9
LP		 887 if ((j = strstrip(t)) && *j) {
888 char *d = NULL;
889
890 if (long_description)
b7def684 891 d = strjoin(long_description, " ", t, NULL);
0b5d26f9
LP		 892 else
893 d = strdup(j);
894
895 if (!d) {
896 r = -ENOMEM;
897 goto finish;
898 }
899
900 free(long_description);
901 long_description = d;
2c4104f0
LP		 902 }
903
2c4104f0
LP		 904 } else
905 state = LSB;
906 }
907 }
908 }
909
37e2941d 910 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
2c4104f0
LP		 911 goto finish;
912
a40eb732 913 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
0bc824be
LP		 914 /* If there a runlevels configured for this service
915 * but none of the standard ones, then we assume this
916 * is some special kind of service (which might be
917 * needed for early boot) and don't create any links
918 * to it. */
919
1124fe6f 920 UNIT(s)->default_dependencies = false;
09cd1ab1 921
09cd1ab1 922 /* Don't timeout special services during boot (like fsck) */
d568a335
MS		 923 s->timeout_start_usec = 0;
924 s->timeout_stop_usec = 0;
925 } else {
926 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
927 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
928 }
929
80876c20 930 /* Special setting for all SysV services */
1f48cf56 931 s->type = SERVICE_FORKING;
f8788303 932 s->remain_after_exit = !s->pid_file;
1835f23c 933 s->guess_main_pid = false;
525ee6f4 934 s->restart = SERVICE_RESTART_NO;
353e12c2 935 s->exec_context.ignore_sigpipe = false;
4819ff03 936 s->kill_context.kill_mode = KILL_PROCESS;
80876c20 937
0b5d26f9
LP		 938 /* We use the long description only if
939 * no short description is set. */
940
941 if (short_description)
942 description = short_description;
943 else if (chkconfig_description)
944 description = chkconfig_description;
945 else if (long_description)
946 description = long_description;
947 else
948 description = NULL;
949
950 if (description) {
951 char *d;
952
e527618d 953 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
0b5d26f9
LP		 954 r = -ENOMEM;
955 goto finish;
956 }
957
ac155bb8 958 u->description = d;
0b5d26f9
LP		 959 }
960
ea87ca5a
LP		 961 /* The priority that has been set in /etc/rcN.d/ hierarchies
962 * takes precedence over what is stored as default in the LSB
963 * header */
964 if (s->sysv_start_priority_from_rcnd >= 0)
965 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
966
ac155bb8 967 u->load_state = UNIT_LOADED;
23a177ef 968 r = 0;
2c4104f0
LP		 969
970finish:
971
972 if (f)
973 fclose(f);
974
0b5d26f9
LP		 975 free(short_description);
976 free(long_description);
977 free(chkconfig_description);
978
2c4104f0
LP		 979 return r;
980}
981
e537352b 982static int service_load_sysv_name(Service *s, const char *name) {
2c4104f0
LP		 983 char **p;
984
985 assert(s);
986 assert(name);
987
c2756a68 988 /* For SysV services we strip the *.sh suffixes. */
3f95f83c 989 if (endswith(name, ".sh.service"))
d017c6ca
LP		 990 return -ENOENT;
991
1124fe6f 992 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
2c4104f0
LP		 993 char *path;
994 int r;
995
b7def684 996 path = strjoin(*p, "/", name, NULL);
44d91056 997 if (!path)
2c4104f0
LP		 998 return -ENOMEM;
999
1000 assert(endswith(path, ".service"));
1001 path[strlen(path)-8] = 0;
1002
e537352b 1003 r = service_load_sysv_path(s, path);
fbe9f3a9 1004
1124fe6f 1005 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
20771ae3 1006 /* Try *.sh source'able init scripts */
fbe9f3a9
LP		 1007 strcat(path, ".sh");
1008 r = service_load_sysv_path(s, path);
1009 }
2c4104f0
LP		 1010 free(path);
1011
23a177ef 1012 if (r < 0)
2c4104f0 1013 return r;
23a177ef 1014
88516c0c 1015 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef 1016 break;
2c4104f0
LP		 1017 }
1018
1019 return 0;
1020}
1021
e537352b 1022static int service_load_sysv(Service *s) {
2c4104f0
LP		 1023 const char *t;
1024 Iterator i;
1025 int r;
1026
5cb5a6ff
LP		 1027 assert(s);
1028
1029 /* Load service data from SysV init scripts, preferably with
1030 * LSB headers ... */
1031
1124fe6f 1032 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
2c4104f0
LP		 1033 return 0;
1034
1124fe6f 1035 if ((t = UNIT(s)->id))
e537352b 1036 if ((r = service_load_sysv_name(s, t)) < 0)
2c4104f0
LP		 1037 return r;
1038
1124fe6f
MS		 1039 if (UNIT(s)->load_state == UNIT_STUB)
1040 SET_FOREACH(t, UNIT(s)->names, i) {
1041 if (t == UNIT(s)->id)
e537352b
LP		 1042 continue;
1043
e364ad06 1044 if ((r = service_load_sysv_name(s, t)) < 0)
23a177ef
LP		 1045 return r;
1046
1124fe6f 1047 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef
LP		 1048 break;
1049 }
2c4104f0
LP		 1050
1051 return 0;
5cb5a6ff 1052}
07459bb6 1053#endif
5cb5a6ff 1054
9fff8a1f 1055static int fsck_fix_order(Service *s) {
ac155bb8 1056 Unit *other;
9fff8a1f
LP		 1057 int r;
1058
1059 assert(s);
1060
1061 if (s->fsck_passno <= 0)
1062 return 0;
1063
1064 /* For each pair of services where both have an fsck priority
1065 * we order things based on it. */
1066
1124fe6f 1067 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
9fff8a1f
LP		 1068 Service *t;
1069 UnitDependency d;
1070
595ed347 1071 t = SERVICE(other);
9fff8a1f
LP		 1072
1073 if (s == t)
1074 continue;
1075
1124fe6f 1076 if (UNIT(t)->load_state != UNIT_LOADED)
9fff8a1f
LP		 1077 continue;
1078
1079 if (t->fsck_passno <= 0)
1080 continue;
1081
1082 if (t->fsck_passno < s->fsck_passno)
1083 d = UNIT_AFTER;
1084 else if (t->fsck_passno > s->fsck_passno)
1085 d = UNIT_BEFORE;
1086 else
1087 continue;
1088
117dcc57
ZJS		 1089 r = unit_add_dependency(UNIT(s), d, UNIT(t), true);
1090 if (r < 0)
9fff8a1f
LP		 1091 return r;
1092 }
1093
1094 return 0;
1095}
1096
243b1432
LP		 1097static int service_verify(Service *s) {
1098 assert(s);
1099
1124fe6f 1100 if (UNIT(s)->load_state != UNIT_LOADED)
243b1432
LP		 1101 return 0;
1102
1103 if (!s->exec_command[SERVICE_EXEC_START]) {
66870f90
ZJS		 1104 log_error_unit(UNIT(s)->id,
1105 "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
243b1432
LP		 1106 return -EINVAL;
1107 }
1108
34e9ba66
LP		 1109 if (s->type != SERVICE_ONESHOT &&
1110 s->exec_command[SERVICE_EXEC_START]->command_next) {
66870f90
ZJS		 1111 log_error_unit(UNIT(s)->id,
1112 "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
6cf6bbc2
LP		 1113 return -EINVAL;
1114 }
1115
b0693d30
MW		 1116 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1117 log_error_unit(UNIT(s)->id,
1118 "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1119 return -EINVAL;
1120 }
1121
05e343b7 1122 if (s->type == SERVICE_DBUS && !s->bus_name) {
66870f90
ZJS		 1123 log_error_unit(UNIT(s)->id,
1124 "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
4d0e5dbd
LP		 1125 return -EINVAL;
1126 }
1127
7e2668c6 1128 if (s->bus_name && s->type != SERVICE_DBUS)
66870f90
ZJS		 1129 log_warning_unit(UNIT(s)->id,
1130 "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
7e2668c6 1131
4819ff03 1132 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
66870f90
ZJS		 1133 log_error_unit(UNIT(s)->id,
1134 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
05e343b7
LP		 1135 return -EINVAL;
1136 }
1137
243b1432
LP		 1138 return 0;
1139}
1140
a40eb732
LP		 1141static int service_add_default_dependencies(Service *s) {
1142 int r;
1143
1144 assert(s);
1145
1146 /* Add a number of automatic dependencies useful for the
1147 * majority of services. */
1148
1149 /* First, pull in base system */
67445f4e 1150 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
117dcc57
ZJS		 1151 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1152 SPECIAL_BASIC_TARGET, NULL, true);
1153 if (r < 0)
a40eb732
LP		 1154 return r;
1155
67445f4e 1156 } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
117dcc57
ZJS		 1157 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1158 SPECIAL_SOCKETS_TARGET, NULL, true);
1159 if (r < 0)
a40eb732 1160 return r;
e3d84721
LP		 1161
1162 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1163 SPECIAL_TIMERS_TARGET, NULL, true);
1164 if (r < 0)
1165 return r;
1166
1167 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1168 SPECIAL_PATHS_TARGET, NULL, true);
1169 if (r < 0)
1170 return r;
a40eb732
LP		 1171 }
1172
1173 /* Second, activate normal shutdown */
117dcc57
ZJS		 1174 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1175 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1176 return r;
a40eb732
LP		 1177}
1178
4dfc092a
LP		 1179static void service_fix_output(Service *s) {
1180 assert(s);
1181
1182 /* If nothing has been explicitly configured, patch default
1183 * output in. If input is socket/tty we avoid this however,
1184 * since in that case we want output to default to the same
1185 * place as we read input from. */
1186
1187 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1188 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1189 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1190 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
4dfc092a
LP		 1191
1192 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1193 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1194 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
4dfc092a
LP		 1195}
1196
e537352b
LP		 1197static int service_load(Unit *u) {
1198 int r;
1199 Service *s = SERVICE(u);
1200
1201 assert(s);
1e2e8133 1202
5cb5a6ff 1203 /* Load a .service file */
c2756a68
LP		 1204 r = unit_load_fragment(u);
1205 if (r < 0)
5cb5a6ff
LP		 1206 return r;
1207
07459bb6 1208#ifdef HAVE_SYSV_COMPAT
bd77d0fc 1209 /* Load a classic init script as a fallback, if we couldn't find anything */
c2756a68
LP		 1210 if (u->load_state == UNIT_STUB) {
1211 r = service_load_sysv(s);
1212 if (r < 0)
23a177ef 1213 return r;
c2756a68 1214 }
07459bb6 1215#endif
d46de8a1 1216
23a177ef 1217 /* Still nothing found? Then let's give up */
ac155bb8 1218 if (u->load_state == UNIT_STUB)
23a177ef 1219 return -ENOENT;
034c6ed7 1220
23a177ef 1221 /* This is a new unit? Then let's add in some extras */
ac155bb8 1222 if (u->load_state == UNIT_LOADED) {
c2756a68
LP		 1223
1224 /* We were able to load something, then let's add in
1225 * the dropin directories. */
1226 r = unit_load_dropin(u);
1227 if (r < 0)
1228 return r;
1229
0b86feac
LP		 1230 if (s->type == _SERVICE_TYPE_INVALID)
1231 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1232
d568a335
MS		 1233 /* Oneshot services have disabled start timeout by default */
1234 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1235 s->timeout_start_usec = 0;
98709151 1236
4e2b0f9b
LP		 1237 service_fix_output(s);
1238
117dcc57
ZJS		 1239 r = unit_add_exec_dependencies(u, &s->exec_context);
1240 if (r < 0)
23a177ef
LP		 1241 return r;
1242
a016b922
LP		 1243 r = unit_add_default_slice(u);
1244 if (r < 0)
1245 return r;
1246
07459bb6 1247#ifdef HAVE_SYSV_COMPAT
117dcc57
ZJS		 1248 r = sysv_fix_order(s);
1249 if (r < 0)
23a177ef 1250 return r;
07459bb6 1251#endif
05e343b7 1252
117dcc57
ZJS		 1253 r = fsck_fix_order(s);
1254 if (r < 0)
9fff8a1f
LP		 1255 return r;
1256
ee0dd802 1257 if (s->bus_name)
05e343b7 1258 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
a40eb732 1259 return r;
c952c6ec
LP		 1260
1261 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1262 s->notify_access = NOTIFY_MAIN;
a40eb732 1263
02c4ef9c
LP		 1264 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1265 s->notify_access = NOTIFY_MAIN;
1266
117dcc57
ZJS		 1267 if (s->type == SERVICE_DBUS || s->bus_name) {
1268 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES,
1269 SPECIAL_DBUS_SOCKET, NULL, true);
1270 if (r < 0)
a40eb732 1271 return r;
117dcc57 1272 }
a40eb732 1273
117dcc57
ZJS		 1274 if (UNIT(s)->default_dependencies) {
1275 r = service_add_default_dependencies(s);
1276 if (r < 0)
a40eb732 1277 return r;
117dcc57 1278 }
e06c73cc 1279
cba6e062 1280 r = unit_exec_context_defaults(u, &s->exec_context);
e06c73cc
LP		 1281 if (r < 0)
1282 return r;
8e274523
LP		 1283 }
1284
243b1432 1285 return service_verify(s);
034c6ed7
LP		 1286}
1287
87f0e418 1288static void service_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 1289
5cb5a6ff 1290 ServiceExecCommand c;
87f0e418 1291 Service *s = SERVICE(u);
47be870b 1292 const char *prefix2;
7fd1b19b 1293 _cleanup_free_ char *p2 = NULL;
5cb5a6ff
LP		 1294
1295 assert(s);
1296
47be870b
LP		 1297 p2 = strappend(prefix, "\t");
1298 prefix2 = p2 ? p2 : prefix;
44d8db9e 1299
5cb5a6ff 1300 fprintf(f,
81a2b7ce 1301 "%sService State: %s\n"
f42806df
LP		 1302 "%sResult: %s\n"
1303 "%sReload Result: %s\n"
81a2b7ce 1304 "%sPermissionsStartOnly: %s\n"
8e274523 1305 "%sRootDirectoryStartOnly: %s\n"
02ee865a 1306 "%sRemainAfterExit: %s\n"
3185a36b 1307 "%sGuessMainPID: %s\n"
c952c6ec 1308 "%sType: %s\n"
2cf3143a 1309 "%sRestart: %s\n"
c952c6ec 1310 "%sNotifyAccess: %s\n",
81a2b7ce 1311 prefix, service_state_to_string(s->state),
f42806df
LP		 1312 prefix, service_result_to_string(s->result),
1313 prefix, service_result_to_string(s->reload_result),
81a2b7ce 1314 prefix, yes_no(s->permissions_start_only),
8e274523 1315 prefix, yes_no(s->root_directory_start_only),
02ee865a 1316 prefix, yes_no(s->remain_after_exit),
3185a36b 1317 prefix, yes_no(s->guess_main_pid),
c952c6ec 1318 prefix, service_type_to_string(s->type),
2cf3143a 1319 prefix, service_restart_to_string(s->restart),
c952c6ec 1320 prefix, notify_access_to_string(s->notify_access));
5cb5a6ff 1321
70123e68
LP		 1322 if (s->control_pid > 0)
1323 fprintf(f,
bb00e604
LP		 1324 "%sControl PID: %lu\n",
1325 prefix, (unsigned long) s->control_pid);
70123e68
LP		 1326
1327 if (s->main_pid > 0)
1328 fprintf(f,
6dfa5494
LP		 1329 "%sMain PID: %lu\n"
1330 "%sMain PID Known: %s\n"
1331 "%sMain PID Alien: %s\n",
1332 prefix, (unsigned long) s->main_pid,
1333 prefix, yes_no(s->main_pid_known),
1334 prefix, yes_no(s->main_pid_alien));
70123e68 1335
034c6ed7
LP		 1336 if (s->pid_file)
1337 fprintf(f,
1338 "%sPIDFile: %s\n",
1339 prefix, s->pid_file);
1340
05e343b7
LP		 1341 if (s->bus_name)
1342 fprintf(f,
1343 "%sBusName: %s\n"
1344 "%sBus Name Good: %s\n",
1345 prefix, s->bus_name,
1346 prefix, yes_no(s->bus_name_good));
1347
4819ff03 1348 kill_context_dump(&s->kill_context, f, prefix);
5cb5a6ff
LP		 1349 exec_context_dump(&s->exec_context, f, prefix);
1350
e537352b 1351 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
5cb5a6ff 1352
44d8db9e
LP		 1353 if (!s->exec_command[c])
1354 continue;
1355
40d50879 1356 fprintf(f, "%s-> %s:\n",
94f04347 1357 prefix, service_exec_command_to_string(c));
44d8db9e
LP		 1358
1359 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 1360 }
44d8db9e 1361
07459bb6 1362#ifdef HAVE_SYSV_COMPAT
1b64d026 1363 if (s->is_sysv)
2c4104f0 1364 fprintf(f,
9fff8a1f
LP		 1365 "%sSysV Init Script has LSB Header: %s\n"
1366 "%sSysVEnabled: %s\n",
9fff8a1f
LP		 1367 prefix, yes_no(s->sysv_has_lsb),
1368 prefix, yes_no(s->sysv_enabled));
2c4104f0
LP		 1369
1370 if (s->sysv_start_priority >= 0)
1371 fprintf(f,
9fff8a1f
LP		 1372 "%sSysVStartPriority: %i\n",
1373 prefix, s->sysv_start_priority);
2c4104f0 1374
8309400a
LP		 1375 if (s->sysv_runlevels)
1376 fprintf(f, "%sSysVRunLevels: %s\n",
1377 prefix, s->sysv_runlevels);
07459bb6 1378#endif
23a177ef 1379
9fff8a1f
LP		 1380 if (s->fsck_passno > 0)
1381 fprintf(f,
1382 "%sFsckPassNo: %i\n",
1383 prefix, s->fsck_passno);
1384
8c47c732
LP		 1385 if (s->status_text)
1386 fprintf(f, "%sStatus Text: %s\n",
1387 prefix, s->status_text);
5cb5a6ff
LP		 1388}
1389
c5419d42 1390static int service_load_pid_file(Service *s, bool may_warn) {
7fd1b19b 1391 _cleanup_free_ char *k = NULL;
034c6ed7 1392 int r;
5925dd3c 1393 pid_t pid;
034c6ed7
LP		 1394
1395 assert(s);
1396
034c6ed7 1397 if (!s->pid_file)
13230d5d 1398 return -ENOENT;
034c6ed7 1399
117dcc57
ZJS		 1400 r = read_one_line_file(s->pid_file, &k);
1401 if (r < 0) {
c5419d42 1402 if (may_warn)
66870f90
ZJS		 1403 log_info_unit(UNIT(s)->id,
1404 "PID file %s not readable (yet?) after %s.",
1405 s->pid_file, service_state_to_string(s->state));
034c6ed7 1406 return r;
5375410b 1407 }
034c6ed7 1408
5925dd3c 1409 r = parse_pid(k, &pid);
bc41f93e
ZJS		 1410 if (r < 0) {
1411 if (may_warn)
1412 log_info_unit(UNIT(s)->id,
1413 "Failed to read PID from file %s: %s",
1414 s->pid_file, strerror(-r));
5925dd3c 1415 return r;
bc41f93e 1416 }
406eaf93 1417
5925dd3c 1418 if (kill(pid, 0) < 0 && errno != EPERM) {
c5419d42 1419 if (may_warn)
66870f90
ZJS		 1420 log_info_unit(UNIT(s)->id,
1421 "PID %lu read from file %s does not exist.",
1422 (unsigned long) pid, s->pid_file);
b8c597d5
LP		 1423 return -ESRCH;
1424 }
1425
db01f8b3
MS		 1426 if (s->main_pid_known) {
1427 if (pid == s->main_pid)
1428 return 0;
1429
66870f90
ZJS		 1430 log_debug_unit(UNIT(s)->id,
1431 "Main PID changing: %lu -> %lu",
1432 (unsigned long) s->main_pid, (unsigned long) pid);
db01f8b3
MS		 1433 service_unwatch_main_pid(s);
1434 s->main_pid_known = false;
3a111838 1435 } else
66870f90
ZJS		 1436 log_debug_unit(UNIT(s)->id,
1437 "Main PID loaded: %lu", (unsigned long) pid);
db01f8b3 1438
117dcc57
ZJS		 1439 r = service_set_main_pid(s, pid);
1440 if (r < 0)
16f6025e
LP		 1441 return r;
1442
117dcc57 1443 r = unit_watch_pid(UNIT(s), pid);
bc41f93e 1444 if (r < 0) {
5925dd3c 1445 /* FIXME: we need to do something here */
bc41f93e
ZJS		 1446 log_warning_unit(UNIT(s)->id,
1447 "Failed to watch PID %lu from service %s",
1448 (unsigned long) pid, UNIT(s)->id);
5925dd3c 1449 return r;
bc41f93e 1450 }
034c6ed7
LP		 1451
1452 return 0;
1453}
1454
4fbf50b3
LP		 1455static int service_search_main_pid(Service *s) {
1456 pid_t pid;
1457 int r;
1458
1459 assert(s);
1460
3185a36b
LP		 1461 /* If we know it anyway, don't ever fallback to unreliable
1462 * heuristics */
4fbf50b3
LP		 1463 if (s->main_pid_known)
1464 return 0;
1465
3185a36b
LP		 1466 if (!s->guess_main_pid)
1467 return 0;
1468
4fbf50b3
LP		 1469 assert(s->main_pid <= 0);
1470
4ad49000 1471 pid = unit_search_main_pid(UNIT(s));
117dcc57 1472 if (pid <= 0)
4fbf50b3
LP		 1473 return -ENOENT;
1474
66870f90
ZJS		 1475 log_debug_unit(UNIT(s)->id,
1476 "Main PID guessed: %lu", (unsigned long) pid);
117dcc57
ZJS		 1477 r = service_set_main_pid(s, pid);
1478 if (r < 0)
4fbf50b3
LP		 1479 return r;
1480
117dcc57
ZJS		 1481 r = unit_watch_pid(UNIT(s), pid);
1482 if (r < 0)
4fbf50b3 1483 /* FIXME: we need to do something here */
a827e373
ZJS		 1484 log_warning_unit(UNIT(s)->id,
1485 "Failed to watch PID %lu from service %s",
1486 (unsigned long) pid, UNIT(s)->id);
4fbf50b3
LP		 1487 return r;
1488
1489 return 0;
1490}
1491
034c6ed7
LP		 1492static void service_set_state(Service *s, ServiceState state) {
1493 ServiceState old_state;
e056b01d 1494 const UnitActiveState *table;
5cb5a6ff
LP		 1495 assert(s);
1496
e056b01d
LP		 1497 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1498
034c6ed7 1499 old_state = s->state;
5cb5a6ff 1500 s->state = state;
034c6ed7 1501
3a111838
MS		 1502 service_unwatch_pid_file(s);
1503
034c6ed7
LP		 1504 if (state != SERVICE_START_PRE &&
1505 state != SERVICE_START &&
1506 state != SERVICE_START_POST &&
1507 state != SERVICE_RELOAD &&
1508 state != SERVICE_STOP &&
1509 state != SERVICE_STOP_SIGTERM &&
1510 state != SERVICE_STOP_SIGKILL &&
1511 state != SERVICE_STOP_POST &&
1512 state != SERVICE_FINAL_SIGTERM &&
1513 state != SERVICE_FINAL_SIGKILL &&
1514 state != SERVICE_AUTO_RESTART)
acbb0225 1515 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1516
7d55e835
LP		 1517 if (state != SERVICE_START &&
1518 state != SERVICE_START_POST &&
034c6ed7
LP		 1519 state != SERVICE_RUNNING &&
1520 state != SERVICE_RELOAD &&
1521 state != SERVICE_STOP &&
1522 state != SERVICE_STOP_SIGTERM &&
867b3b7d 1523 state != SERVICE_STOP_SIGKILL) {
5e94833f 1524 service_unwatch_main_pid(s);
867b3b7d
LP		 1525 s->main_command = NULL;
1526 }
034c6ed7
LP		 1527
1528 if (state != SERVICE_START_PRE &&
1529 state != SERVICE_START &&
1530 state != SERVICE_START_POST &&
1531 state != SERVICE_RELOAD &&
1532 state != SERVICE_STOP &&
1533 state != SERVICE_STOP_SIGTERM &&
1534 state != SERVICE_STOP_SIGKILL &&
1535 state != SERVICE_STOP_POST &&
1536 state != SERVICE_FINAL_SIGTERM &&
e537352b 1537 state != SERVICE_FINAL_SIGKILL) {
5e94833f 1538 service_unwatch_control_pid(s);
034c6ed7 1539 s->control_command = NULL;
a16e1123 1540 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
e537352b 1541 }
034c6ed7 1542
4f2d528d
LP		 1543 if (state != SERVICE_START_PRE &&
1544 state != SERVICE_START &&
6cf6bbc2
LP		 1545 state != SERVICE_START_POST &&
1546 state != SERVICE_RUNNING &&
1547 state != SERVICE_RELOAD &&
1548 state != SERVICE_STOP &&
1549 state != SERVICE_STOP_SIGTERM &&
1550 state != SERVICE_STOP_SIGKILL &&
1551 state != SERVICE_STOP_POST &&
1552 state != SERVICE_FINAL_SIGTERM &&
1553 state != SERVICE_FINAL_SIGKILL &&
1124fe6f 1554 !(state == SERVICE_DEAD && UNIT(s)->job)) {
4f2d528d 1555 service_close_socket_fd(s);
6cf6bbc2
LP		 1556 service_connection_unref(s);
1557 }
4f2d528d 1558
6d594baa 1559 if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
a6927d7f
MO		 1560 service_stop_watchdog(s);
1561
f6023656
LP		 1562 /* For the inactive states unit_notify() will trim the cgroup,
1563 * but for exit we have to do that ourselves... */
1124fe6f 1564 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
4ad49000 1565 unit_destroy_cgroup(UNIT(s));
f6023656 1566
e537352b 1567 if (old_state != state)
66870f90
ZJS		 1568 log_debug_unit(UNIT(s)->id,
1569 "%s changed %s -> %s", UNIT(s)->id,
1570 service_state_to_string(old_state),
1571 service_state_to_string(state));
acbb0225 1572
e056b01d 1573 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
f42806df 1574 s->reload_result = SERVICE_SUCCESS;
034c6ed7
LP		 1575}
1576
a16e1123
LP		 1577static int service_coldplug(Unit *u) {
1578 Service *s = SERVICE(u);
1579 int r;
1580
1581 assert(s);
1582 assert(s->state == SERVICE_DEAD);
1583
1584 if (s->deserialized_state != s->state) {
1585
1586 if (s->deserialized_state == SERVICE_START_PRE ||
1587 s->deserialized_state == SERVICE_START ||
1588 s->deserialized_state == SERVICE_START_POST ||
1589 s->deserialized_state == SERVICE_RELOAD ||
1590 s->deserialized_state == SERVICE_STOP ||
1591 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1592 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1593 s->deserialized_state == SERVICE_STOP_POST ||
1594 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1595 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
e558336f 1596 s->deserialized_state == SERVICE_AUTO_RESTART) {
6c12b52e 1597
d568a335 1598 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
e558336f
LP		 1599 usec_t k;
1600
d568a335 1601 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
e558336f 1602
36697dc0
LP		 1603 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1604 if (r < 0)
e558336f
LP		 1605 return r;
1606 }
1607 }
a16e1123
LP		 1608
1609 if ((s->deserialized_state == SERVICE_START &&
1610 (s->type == SERVICE_FORKING ||
8c47c732 1611 s->type == SERVICE_DBUS ||
34e9ba66 1612 s->type == SERVICE_ONESHOT ||
8c47c732 1613 s->type == SERVICE_NOTIFY)) ||
a16e1123
LP		 1614 s->deserialized_state == SERVICE_START_POST ||
1615 s->deserialized_state == SERVICE_RUNNING ||
1616 s->deserialized_state == SERVICE_RELOAD ||
1617 s->deserialized_state == SERVICE_STOP ||
1618 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1619 s->deserialized_state == SERVICE_STOP_SIGKILL)
117dcc57
ZJS		 1620 if (s->main_pid > 0) {
1621 r = unit_watch_pid(UNIT(s), s->main_pid);
1622 if (r < 0)
a16e1123 1623 return r;
117dcc57 1624 }
a16e1123
LP		 1625
1626 if (s->deserialized_state == SERVICE_START_PRE ||
1627 s->deserialized_state == SERVICE_START ||
1628 s->deserialized_state == SERVICE_START_POST ||
1629 s->deserialized_state == SERVICE_RELOAD ||
1630 s->deserialized_state == SERVICE_STOP ||
1631 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1632 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1633 s->deserialized_state == SERVICE_STOP_POST ||
1634 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1635 s->deserialized_state == SERVICE_FINAL_SIGKILL)
117dcc57
ZJS		 1636 if (s->control_pid > 0) {
1637 r = unit_watch_pid(UNIT(s), s->control_pid);
1638 if (r < 0)
a16e1123 1639 return r;
117dcc57 1640 }
a16e1123 1641
bb242b7b
MO		 1642 if (s->deserialized_state == SERVICE_START_POST ||
1643 s->deserialized_state == SERVICE_RUNNING)
1644 service_handle_watchdog(s);
1645
a16e1123
LP		 1646 service_set_state(s, s->deserialized_state);
1647 }
a16e1123
LP		 1648 return 0;
1649}
1650
44d8db9e
LP		 1651static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1652 Iterator i;
1653 int r;
1654 int *rfds = NULL;
1655 unsigned rn_fds = 0;
57020a3a 1656 Unit *u;
44d8db9e
LP		 1657
1658 assert(s);
1659 assert(fds);
1660 assert(n_fds);
1661
6cf6bbc2
LP		 1662 if (s->socket_fd >= 0)
1663 return 0;
1664
1124fe6f 1665 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
44d8db9e
LP		 1666 int *cfds;
1667 unsigned cn_fds;
57020a3a
LP		 1668 Socket *sock;
1669
ac155bb8 1670 if (u->type != UNIT_SOCKET)
57020a3a
LP		 1671 continue;
1672
1673 sock = SOCKET(u);
44d8db9e 1674
117dcc57
ZJS		 1675 r = socket_collect_fds(sock, &cfds, &cn_fds);
1676 if (r < 0)
44d8db9e
LP		 1677 goto fail;
1678
1679 if (!cfds)
1680 continue;
1681
1682 if (!rfds) {
1683 rfds = cfds;
1684 rn_fds = cn_fds;
1685 } else {
1686 int *t;
1687
117dcc57
ZJS		 1688 t = new(int, rn_fds+cn_fds);
1689 if (!t) {
44d8db9e
LP		 1690 free(cfds);
1691 r = -ENOMEM;
1692 goto fail;
1693 }
1694
9c1b183c
LP		 1695 memcpy(t, rfds, rn_fds * sizeof(int));
1696 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
44d8db9e
LP		 1697 free(rfds);
1698 free(cfds);
1699
1700 rfds = t;
1701 rn_fds = rn_fds+cn_fds;
1702 }
1703 }
1704
1705 *fds = rfds;
1706 *n_fds = rn_fds;
3e33402a 1707
44d8db9e
LP		 1708 return 0;
1709
1710fail:
1711 free(rfds);
3e33402a 1712
44d8db9e
LP		 1713 return r;
1714}
1715
81a2b7ce
LP		 1716static int service_spawn(
1717 Service *s,
1718 ExecCommand *c,
1719 bool timeout,
1720 bool pass_fds,
1721 bool apply_permissions,
1722 bool apply_chroot,
1e3ad081 1723 bool apply_tty_stdin,
c952c6ec 1724 bool set_notify_socket,
ecedd90f 1725 bool is_control,
81a2b7ce
LP		 1726 pid_t *_pid) {
1727
034c6ed7
LP		 1728 pid_t pid;
1729 int r;
117dcc57 1730 int *fds = NULL;
7fd1b19b 1731 _cleanup_free_ int *fdsbuf = NULL;
2105e76a 1732 unsigned n_fds = 0, n_env = 0;
7fd1b19b 1733 _cleanup_strv_free_ char
117dcc57 1734 **argv = NULL, **final_env = NULL, **our_env = NULL;
4ad49000 1735 const char *path;
034c6ed7
LP		 1736
1737 assert(s);
1738 assert(c);
1739 assert(_pid);
1740
4ad49000
LP		 1741 unit_realize_cgroup(UNIT(s));
1742
6cf6bbc2
LP		 1743 if (pass_fds ||
1744 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1745 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1746 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1747
4f2d528d
LP		 1748 if (s->socket_fd >= 0) {
1749 fds = &s->socket_fd;
1750 n_fds = 1;
6cf6bbc2 1751 } else {
117dcc57
ZJS		 1752 r = service_collect_fds(s, &fdsbuf, &n_fds);
1753 if (r < 0)
6cf6bbc2
LP		 1754 goto fail;
1755
1756 fds = fdsbuf;
1757 }
4f2d528d 1758 }
44d8db9e 1759
d568a335 1760 if (timeout && s->timeout_start_usec) {
117dcc57
ZJS		 1761 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1762 s->timeout_start_usec, &s->timer_watch);
d568a335 1763 if (r < 0)
034c6ed7
LP		 1764 goto fail;
1765 } else
acbb0225 1766 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1767
19f6d710
LP		 1768 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1769 if (r < 0)
9e2f7c11 1770 goto fail;
9e2f7c11 1771
97ae63e2
LP		 1772 our_env = new0(char*, 5);
1773 if (!our_env) {
2105e76a
LP		 1774 r = -ENOMEM;
1775 goto fail;
1776 }
c952c6ec 1777
2105e76a 1778 if (set_notify_socket)
1124fe6f 1779 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
c952c6ec
LP		 1780 r = -ENOMEM;
1781 goto fail;
1782 }
1783
2105e76a
LP		 1784 if (s->main_pid > 0)
1785 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
c952c6ec
LP		 1786 r = -ENOMEM;
1787 goto fail;
1788 }
2105e76a 1789
6e0bcc98
MO		 1790 if (s->watchdog_usec > 0)
1791 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1792 r = -ENOMEM;
1793 goto fail;
1794 }
1795
4ad49000 1796 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
97ae63e2
LP		 1797 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1798 r = -ENOMEM;
1799 goto fail;
1800 }
1801
1802 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1803 if (!final_env) {
2105e76a
LP		 1804 r = -ENOMEM;
1805 goto fail;
1806 }
c952c6ec 1807
4ad49000
LP		 1808 if (is_control && UNIT(s)->cgroup_path) {
1809 path = strappenda(UNIT(s)->cgroup_path, "/control");
1810 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1811 } else
1812 path = UNIT(s)->cgroup_path;
1813
9e2f7c11
LP		 1814 r = exec_spawn(c,
1815 argv,
1816 &s->exec_context,
1817 fds, n_fds,
2105e76a 1818 final_env,
9e2f7c11
LP		 1819 apply_permissions,
1820 apply_chroot,
1e3ad081 1821 apply_tty_stdin,
1124fe6f 1822 UNIT(s)->manager->confirm_spawn,
13b84ec7 1823 UNIT(s)->manager->cgroup_supported,
4ad49000 1824 path,
62bca2c6 1825 UNIT(s)->id,
f2b68789 1826 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
9e2f7c11 1827 &pid);
9e2f7c11 1828 if (r < 0)
034c6ed7
LP		 1829 goto fail;
1830
117dcc57
ZJS		 1831 r = unit_watch_pid(UNIT(s), pid);
1832 if (r < 0)
034c6ed7
LP		 1833 /* FIXME: we need to do something here */
1834 goto fail;
1835
1836 *_pid = pid;
1837
5cb5a6ff 1838 return 0;
034c6ed7
LP		 1839
1840fail:
1841 if (timeout)
acbb0225 1842 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7
LP		 1843
1844 return r;
1845}
1846
80876c20
LP		 1847static int main_pid_good(Service *s) {
1848 assert(s);
1849
1850 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1851 * don't know */
1852
1853 /* If we know the pid file, then lets just check if it is
1854 * still valid */
6dfa5494
LP		 1855 if (s->main_pid_known) {
1856
1857 /* If it's an alien child let's check if it is still
1858 * alive ... */
62220cf7 1859 if (s->main_pid_alien && s->main_pid > 0)
6dfa5494
LP		 1860 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1861
1862 /* .. otherwise assume we'll get a SIGCHLD for it,
1863 * which we really should wait for to collect exit
1864 * status and code */
80876c20 1865 return s->main_pid > 0;
6dfa5494 1866 }
80876c20
LP		 1867
1868 /* We don't know the pid */
1869 return -EAGAIN;
1870}
1871
44a6b1b6 1872_pure_ static int control_pid_good(Service *s) {
80876c20
LP		 1873 assert(s);
1874
1875 return s->control_pid > 0;
1876}
1877
1878static int cgroup_good(Service *s) {
1879 int r;
1880
1881 assert(s);
1882
4ad49000
LP		 1883 if (!UNIT(s)->cgroup_path)
1884 return 0;
1885
1886 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
117dcc57 1887 if (r < 0)
80876c20
LP		 1888 return r;
1889
1890 return !r;
1891}
1892
f42806df 1893static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
034c6ed7
LP		 1894 int r;
1895 assert(s);
1896
f42806df
LP		 1897 if (f != SERVICE_SUCCESS)
1898 s->result = f;
034c6ed7 1899
0c7f15b3
MS		 1900 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1901
034c6ed7 1902 if (allow_restart &&
47342320 1903 !s->forbid_restart &&
034c6ed7 1904 (s->restart == SERVICE_RESTART_ALWAYS ||
f42806df
LP		 1905 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1906 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
dc99a976 1907 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
f42806df 1908 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
96342de6
LN		 1909 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1910 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1911 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1912 (s->result != SERVICE_FAILURE_SIGNAL ||
1913 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1914 ) {
034c6ed7 1915
36697dc0 1916 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
f42806df 1917 if (r < 0)
034c6ed7
LP		 1918 goto fail;
1919
1920 service_set_state(s, SERVICE_AUTO_RESTART);
0c7f15b3 1921 }
034c6ed7 1922
47342320
LP		 1923 s->forbid_restart = false;
1924
c17ec25e
MS		 1925 /* we want fresh tmpdirs in case service is started again immediately */
1926 exec_context_tmp_dirs_done(&s->exec_context);
1927
9285c9ff
LN		 1928 /* Try to delete the pid file. At this point it will be
1929 * out-of-date, and some software might be confused by it, so
1930 * let's remove it. */
1931 if (s->pid_file)
1932 unlink_noerrno(s->pid_file);
1933
034c6ed7
LP		 1934 return;
1935
1936fail:
66870f90
ZJS		 1937 log_warning_unit(UNIT(s)->id,
1938 "%s failed to run install restart timer: %s",
1939 UNIT(s)->id, strerror(-r));
f42806df 1940 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1941}
1942
f42806df 1943static void service_enter_stop_post(Service *s, ServiceResult f) {
034c6ed7
LP		 1944 int r;
1945 assert(s);
1946
f42806df
LP		 1947 if (f != SERVICE_SUCCESS)
1948 s->result = f;
034c6ed7 1949
5e94833f
LP		 1950 service_unwatch_control_pid(s);
1951
117dcc57
ZJS		 1952 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1953 if (s->control_command) {
867b3b7d
LP		 1954 s->control_command_id = SERVICE_EXEC_STOP_POST;
1955
ecedd90f
LP		 1956 r = service_spawn(s,
1957 s->control_command,
1958 true,
1959 false,
1960 !s->permissions_start_only,
1961 !s->root_directory_start_only,
1962 true,
1963 false,
1964 true,
1965 &s->control_pid);
1966 if (r < 0)
034c6ed7
LP		 1967 goto fail;
1968
d6ea93e3 1969
80876c20
LP		 1970 service_set_state(s, SERVICE_STOP_POST);
1971 } else
c961869a 1972 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 1973
1974 return;
1975
1976fail:
66870f90
ZJS		 1977 log_warning_unit(UNIT(s)->id,
1978 "%s failed to run 'stop-post' task: %s",
1979 UNIT(s)->id, strerror(-r));
f42806df 1980 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1981}
1982
f42806df 1983static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
034c6ed7 1984 int r;
034c6ed7
LP		 1985
1986 assert(s);
1987
f42806df
LP		 1988 if (f != SERVICE_SUCCESS)
1989 s->result = f;
034c6ed7 1990
cd2086fe
LP		 1991 r = unit_kill_context(
1992 UNIT(s),
1993 &s->kill_context,
1994 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1995 s->main_pid,
1996 s->control_pid,
1997 s->main_pid_alien);
1998 if (r < 0)
1999 goto fail;
034c6ed7 2000
cd2086fe 2001 if (r > 0) {
d568a335 2002 if (s->timeout_stop_usec > 0) {
117dcc57
ZJS		 2003 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2004 s->timeout_stop_usec, &s->timer_watch);
d568a335 2005 if (r < 0)
e558336f 2006 goto fail;
d568a335 2007 }
d6ea93e3 2008
80876c20
LP		 2009 service_set_state(s, state);
2010 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2011 service_enter_stop_post(s, SERVICE_SUCCESS);
80876c20 2012 else
f42806df 2013 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 2014
2015 return;
2016
2017fail:
66870f90
ZJS		 2018 log_warning_unit(UNIT(s)->id,
2019 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
034c6ed7 2020
80876c20 2021 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2022 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
034c6ed7 2023 else
f42806df 2024 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2025}
2026
f42806df 2027static void service_enter_stop(Service *s, ServiceResult f) {
034c6ed7 2028 int r;
5925dd3c 2029
034c6ed7
LP		 2030 assert(s);
2031
f42806df
LP		 2032 if (f != SERVICE_SUCCESS)
2033 s->result = f;
034c6ed7 2034
5e94833f
LP		 2035 service_unwatch_control_pid(s);
2036
117dcc57
ZJS		 2037 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2038 if (s->control_command) {
867b3b7d
LP		 2039 s->control_command_id = SERVICE_EXEC_STOP;
2040
ecedd90f
LP		 2041 r = service_spawn(s,
2042 s->control_command,
2043 true,
2044 false,
2045 !s->permissions_start_only,
2046 !s->root_directory_start_only,
2047 false,
2048 false,
2049 true,
2050 &s->control_pid);
2051 if (r < 0)
034c6ed7
LP		 2052 goto fail;
2053
80876c20
LP		 2054 service_set_state(s, SERVICE_STOP);
2055 } else
f42806df 2056 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 2057
2058 return;
2059
2060fail:
66870f90
ZJS		 2061 log_warning_unit(UNIT(s)->id,
2062 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2063 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2064}
2065
f42806df 2066static void service_enter_running(Service *s, ServiceResult f) {
4eab639f 2067 int main_pid_ok, cgroup_ok;
80876c20
LP		 2068 assert(s);
2069
f42806df
LP		 2070 if (f != SERVICE_SUCCESS)
2071 s->result = f;
80876c20 2072
4eab639f
LP		 2073 main_pid_ok = main_pid_good(s);
2074 cgroup_ok = cgroup_good(s);
2075
2076 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
05e343b7 2077 (s->bus_name_good || s->type != SERVICE_DBUS))
80876c20 2078 service_set_state(s, SERVICE_RUNNING);
02ee865a 2079 else if (s->remain_after_exit)
80876c20
LP		 2080 service_set_state(s, SERVICE_EXITED);
2081 else
f42806df 2082 service_enter_stop(s, SERVICE_SUCCESS);
80876c20
LP		 2083}
2084
034c6ed7
LP		 2085static void service_enter_start_post(Service *s) {
2086 int r;
2087 assert(s);
2088
5e94833f
LP		 2089 service_unwatch_control_pid(s);
2090
bb242b7b
MO		 2091 if (s->watchdog_usec > 0)
2092 service_reset_watchdog(s);
2093
117dcc57
ZJS		 2094 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2095 if (s->control_command) {
867b3b7d
LP		 2096 s->control_command_id = SERVICE_EXEC_START_POST;
2097
ecedd90f
LP		 2098 r = service_spawn(s,
2099 s->control_command,
2100 true,
2101 false,
2102 !s->permissions_start_only,
2103 !s->root_directory_start_only,
2104 false,
2105 false,
2106 true,
2107 &s->control_pid);
2108 if (r < 0)
034c6ed7
LP		 2109 goto fail;
2110
80876c20
LP		 2111 service_set_state(s, SERVICE_START_POST);
2112 } else
f42806df 2113 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2114
2115 return;
2116
2117fail:
66870f90
ZJS		 2118 log_warning_unit(UNIT(s)->id,
2119 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2120 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2121}
2122
4ad49000
LP		 2123static void service_kill_control_processes(Service *s) {
2124 char *p;
2125
2126 if (!UNIT(s)->cgroup_path)
2127 return;
2128
2129 p = strappenda(UNIT(s)->cgroup_path, "/control");
4ad49000
LP		 2130 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2131}
2132
034c6ed7 2133static void service_enter_start(Service *s) {
4ad49000 2134 ExecCommand *c;
034c6ed7
LP		 2135 pid_t pid;
2136 int r;
2137
2138 assert(s);
2139
2140 assert(s->exec_command[SERVICE_EXEC_START]);
34e9ba66 2141 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
034c6ed7 2142
41efeaec
LP		 2143 service_unwatch_control_pid(s);
2144 service_unwatch_main_pid(s);
80876c20 2145
8f53a7b8
LP		 2146 /* We want to ensure that nobody leaks processes from
2147 * START_PRE here, so let's go on a killing spree, People
2148 * should not spawn long running processes from START_PRE. */
4ad49000 2149 service_kill_control_processes(s);
8f53a7b8 2150
867b3b7d
LP		 2151 if (s->type == SERVICE_FORKING) {
2152 s->control_command_id = SERVICE_EXEC_START;
2153 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2154
2155 s->main_command = NULL;
2156 } else {
2157 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2158 s->control_command = NULL;
2159
2160 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2161 }
34e9ba66 2162
ecedd90f
LP		 2163 r = service_spawn(s,
2164 c,
117dcc57
ZJS		 2165 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2166 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
ecedd90f
LP		 2167 true,
2168 true,
2169 true,
2170 true,
2171 s->notify_access != NOTIFY_NONE,
2172 false,
2173 &pid);
2174 if (r < 0)
034c6ed7
LP		 2175 goto fail;
2176
f2b68789 2177 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
034c6ed7
LP		 2178 /* For simple services we immediately start
2179 * the START_POST binaries. */
2180
5925dd3c 2181 service_set_main_pid(s, pid);
034c6ed7
LP		 2182 service_enter_start_post(s);
2183
2184 } else if (s->type == SERVICE_FORKING) {
2185
2186 /* For forking services we wait until the start
2187 * process exited. */
2188
e55224ca 2189 s->control_pid = pid;
80876c20
LP		 2190 service_set_state(s, SERVICE_START);
2191
34e9ba66 2192 } else if (s->type == SERVICE_ONESHOT ||
8c47c732
LP		 2193 s->type == SERVICE_DBUS ||
2194 s->type == SERVICE_NOTIFY) {
7d55e835 2195
34e9ba66 2196 /* For oneshot services we wait until the start
7d55e835
LP		 2197 * process exited, too, but it is our main process. */
2198
05e343b7 2199 /* For D-Bus services we know the main pid right away,
8c47c732
LP		 2200 * but wait for the bus name to appear on the
2201 * bus. Notify services are similar. */
05e343b7 2202
5925dd3c 2203 service_set_main_pid(s, pid);
80876c20 2204 service_set_state(s, SERVICE_START);
034c6ed7
LP		 2205 } else
2206 assert_not_reached("Unknown service type");
2207
2208 return;
2209
2210fail:
66870f90
ZJS		 2211 log_warning_unit(UNIT(s)->id,
2212 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2213 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2214}
2215
2216static void service_enter_start_pre(Service *s) {
2217 int r;
2218
2219 assert(s);
2220
5e94833f
LP		 2221 service_unwatch_control_pid(s);
2222
117dcc57
ZJS		 2223 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2224 if (s->control_command) {
8f53a7b8
LP		 2225 /* Before we start anything, let's clear up what might
2226 * be left from previous runs. */
4ad49000 2227 service_kill_control_processes(s);
8f53a7b8 2228
867b3b7d
LP		 2229 s->control_command_id = SERVICE_EXEC_START_PRE;
2230
ecedd90f
LP		 2231 r = service_spawn(s,
2232 s->control_command,
2233 true,
2234 false,
2235 !s->permissions_start_only,
2236 !s->root_directory_start_only,
2237 true,
2238 false,
2239 true,
2240 &s->control_pid);
2241 if (r < 0)
034c6ed7
LP		 2242 goto fail;
2243
80876c20
LP		 2244 service_set_state(s, SERVICE_START_PRE);
2245 } else
034c6ed7
LP		 2246 service_enter_start(s);
2247
2248 return;
2249
2250fail:
66870f90
ZJS		 2251 log_warning_unit(UNIT(s)->id,
2252 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2253 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2254}
2255
2256static void service_enter_restart(Service *s) {
2257 int r;
398ef8ba
LP		 2258 DBusError error;
2259
034c6ed7 2260 assert(s);
398ef8ba 2261 dbus_error_init(&error);
034c6ed7 2262
a8bb2e65
LP		 2263 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2264 /* Don't restart things if we are going down anyway */
66870f90
ZJS		 2265 log_info_unit(UNIT(s)->id,
2266 "Stop job pending for unit, delaying automatic restart.");
2edfa366 2267
36697dc0 2268 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
a8bb2e65 2269 if (r < 0)
2edfa366 2270 goto fail;
feae8adb
DW		 2271
2272 return;
2edfa366
LP		 2273 }
2274
48bb5876
DW		 2275 /* Any units that are bound to this service must also be
2276 * restarted. We use JOB_RESTART (instead of the more obvious
2277 * JOB_START) here so that those dependency jobs will be added
2278 * as well. */
2279 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2280 if (r < 0)
034c6ed7
LP		 2281 goto fail;
2282
a8bb2e65
LP		 2283 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2284 * it will be canceled as part of the service_stop() call that
2285 * is executed as part of JOB_RESTART. */
2286
66870f90
ZJS		 2287 log_debug_unit(UNIT(s)->id,
2288 "%s scheduled restart job.", UNIT(s)->id);
034c6ed7
LP		 2289 return;
2290
2291fail:
66870f90
ZJS		 2292 log_warning_unit(UNIT(s)->id,
2293 "%s failed to schedule restart job: %s",
2294 UNIT(s)->id, bus_error(&error, -r));
f42806df 2295 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
398ef8ba
LP		 2296
2297 dbus_error_free(&error);
034c6ed7
LP		 2298}
2299
2300static void service_enter_reload(Service *s) {
2301 int r;
2302
2303 assert(s);
2304
5e94833f
LP		 2305 service_unwatch_control_pid(s);
2306
117dcc57
ZJS		 2307 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2308 if (s->control_command) {
867b3b7d
LP		 2309 s->control_command_id = SERVICE_EXEC_RELOAD;
2310
ecedd90f
LP		 2311 r = service_spawn(s,
2312 s->control_command,
2313 true,
2314 false,
2315 !s->permissions_start_only,
2316 !s->root_directory_start_only,
2317 false,
2318 false,
2319 true,
2320 &s->control_pid);
2321 if (r < 0)
034c6ed7
LP		 2322 goto fail;
2323
80876c20
LP		 2324 service_set_state(s, SERVICE_RELOAD);
2325 } else
f42806df 2326 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2327
2328 return;
2329
2330fail:
66870f90
ZJS		 2331 log_warning_unit(UNIT(s)->id,
2332 "%s failed to run 'reload' task: %s",
2333 UNIT(s)->id, strerror(-r));
f42806df
LP		 2334 s->reload_result = SERVICE_FAILURE_RESOURCES;
2335 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2336}
2337
f42806df 2338static void service_run_next_control(Service *s) {
034c6ed7
LP		 2339 int r;
2340
2341 assert(s);
2342 assert(s->control_command);
2343 assert(s->control_command->command_next);
2344
34e9ba66 2345 assert(s->control_command_id != SERVICE_EXEC_START);
034c6ed7 2346
34e9ba66 2347 s->control_command = s->control_command->command_next;
5e94833f
LP		 2348 service_unwatch_control_pid(s);
2349
ecedd90f
LP		 2350 r = service_spawn(s,
2351 s->control_command,
2352 true,
2353 false,
2354 !s->permissions_start_only,
2355 !s->root_directory_start_only,
2356 s->control_command_id == SERVICE_EXEC_START_PRE ||
2357 s->control_command_id == SERVICE_EXEC_STOP_POST,
2358 false,
2359 true,
2360 &s->control_pid);
2361 if (r < 0)
034c6ed7
LP		 2362 goto fail;
2363
2364 return;
2365
2366fail:
66870f90
ZJS		 2367 log_warning_unit(UNIT(s)->id,
2368 "%s failed to run next control task: %s",
2369 UNIT(s)->id, strerror(-r));
034c6ed7 2370
80876c20 2371 if (s->state == SERVICE_START_PRE)
f42806df 2372 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
80876c20 2373 else if (s->state == SERVICE_STOP)
f42806df 2374 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7 2375 else if (s->state == SERVICE_STOP_POST)
f42806df 2376 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
e2f3b44c 2377 else if (s->state == SERVICE_RELOAD) {
f42806df
LP		 2378 s->reload_result = SERVICE_FAILURE_RESOURCES;
2379 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c 2380 } else
f42806df 2381 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
5cb5a6ff
LP		 2382}
2383
f42806df 2384static void service_run_next_main(Service *s) {
34e9ba66
LP		 2385 pid_t pid;
2386 int r;
2387
2388 assert(s);
867b3b7d
LP		 2389 assert(s->main_command);
2390 assert(s->main_command->command_next);
2391 assert(s->type == SERVICE_ONESHOT);
34e9ba66 2392
867b3b7d 2393 s->main_command = s->main_command->command_next;
34e9ba66
LP		 2394 service_unwatch_main_pid(s);
2395
ecedd90f
LP		 2396 r = service_spawn(s,
2397 s->main_command,
98709151 2398 true,
ecedd90f
LP		 2399 true,
2400 true,
2401 true,
2402 true,
2403 s->notify_access != NOTIFY_NONE,
2404 false,
2405 &pid);
2406 if (r < 0)
34e9ba66
LP		 2407 goto fail;
2408
2409 service_set_main_pid(s, pid);
2410
2411 return;
2412
2413fail:
66870f90
ZJS		 2414 log_warning_unit(UNIT(s)->id,
2415 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
f42806df 2416 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
34e9ba66
LP		 2417}
2418
4b939747
MO		 2419static int service_start_limit_test(Service *s) {
2420 assert(s);
2421
2422 if (ratelimit_test(&s->start_limit))
2423 return 0;
2424
2425 switch (s->start_limit_action) {
2426
2427 case SERVICE_START_LIMIT_NONE:
66870f90
ZJS		 2428 log_warning_unit(UNIT(s)->id,
2429 "%s start request repeated too quickly, refusing to start.",
2430 UNIT(s)->id);
4b939747
MO		 2431 break;
2432
2433 case SERVICE_START_LIMIT_REBOOT: {
2434 DBusError error;
2435 int r;
2436
2437 dbus_error_init(&error);
2438
66870f90
ZJS		 2439 log_warning_unit(UNIT(s)->id,
2440 "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
4b939747 2441
117dcc57
ZJS		 2442 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2443 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2444 true, &error, NULL);
4b939747 2445 if (r < 0) {
66870f90
ZJS		 2446 log_error_unit(UNIT(s)->id,
2447 "Failed to reboot: %s.", bus_error(&error, r));
4b939747
MO		 2448 dbus_error_free(&error);
2449 }
2450
2451 break;
2452 }
2453
2454 case SERVICE_START_LIMIT_REBOOT_FORCE:
66870f90
ZJS		 2455 log_warning_unit(UNIT(s)->id,
2456 "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
4b939747
MO		 2457 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2458 break;
2459
2460 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
66870f90
ZJS		 2461 log_warning_unit(UNIT(s)->id,
2462 "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
0049f05a 2463 sync();
4b939747
MO		 2464 reboot(RB_AUTOBOOT);
2465 break;
2466
2467 default:
66870f90
ZJS		 2468 log_error_unit(UNIT(s)->id,
2469 "start limit action=%i", s->start_limit_action);
4b939747
MO		 2470 assert_not_reached("Unknown StartLimitAction.");
2471 }
2472
2473 return -ECANCELED;
2474}
2475
87f0e418
LP		 2476static int service_start(Unit *u) {
2477 Service *s = SERVICE(u);
4b939747 2478 int r;
5cb5a6ff
LP		 2479
2480 assert(s);
2481
034c6ed7
LP		 2482 /* We cannot fulfill this request right now, try again later
2483 * please! */
2484 if (s->state == SERVICE_STOP ||
2485 s->state == SERVICE_STOP_SIGTERM ||
2486 s->state == SERVICE_STOP_SIGKILL ||
2487 s->state == SERVICE_STOP_POST ||
2488 s->state == SERVICE_FINAL_SIGTERM ||
2489 s->state == SERVICE_FINAL_SIGKILL)
5cb5a6ff
LP		 2490 return -EAGAIN;
2491
034c6ed7
LP		 2492 /* Already on it! */
2493 if (s->state == SERVICE_START_PRE ||
2494 s->state == SERVICE_START ||
2495 s->state == SERVICE_START_POST)
2496 return 0;
2497
2e9d6c12 2498 /* A service that will be restarted must be stopped first to
7f2cddae 2499 * trigger BindsTo and/or OnFailure dependencies. If a user
2e9d6c12 2500 * does not want to wait for the holdoff time to elapse, the
d4943dc7
LP		 2501 * service should be manually restarted, not started. We
2502 * simply return EAGAIN here, so that any start jobs stay
2503 * queued, and assume that the auto restart timer will
2504 * eventually trigger the restart. */
2505 if (s->state == SERVICE_AUTO_RESTART)
a8bb2e65 2506 return -EAGAIN;
2e9d6c12
DW		 2507
2508 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
5cb5a6ff 2509
1e2e8133 2510 /* Make sure we don't enter a busy loop of some kind. */
4b939747 2511 r = service_start_limit_test(s);
c2f34808 2512 if (r < 0) {
8d1b002a 2513 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
4b939747 2514 return r;
c2f34808 2515 }
1e2e8133 2516
f42806df
LP		 2517 s->result = SERVICE_SUCCESS;
2518 s->reload_result = SERVICE_SUCCESS;
034c6ed7 2519 s->main_pid_known = false;
6dfa5494 2520 s->main_pid_alien = false;
47342320 2521 s->forbid_restart = false;
034c6ed7
LP		 2522
2523 service_enter_start_pre(s);
2524 return 0;
5cb5a6ff
LP		 2525}
2526
87f0e418
LP		 2527static int service_stop(Unit *u) {
2528 Service *s = SERVICE(u);
5cb5a6ff
LP		 2529
2530 assert(s);
2531
f0c7b229 2532 /* Don't create restart jobs from here. */
47342320 2533 s->forbid_restart = true;
034c6ed7 2534
e537352b
LP		 2535 /* Already on it */
2536 if (s->state == SERVICE_STOP ||
2537 s->state == SERVICE_STOP_SIGTERM ||
2538 s->state == SERVICE_STOP_SIGKILL ||
2539 s->state == SERVICE_STOP_POST ||
2540 s->state == SERVICE_FINAL_SIGTERM ||
2541 s->state == SERVICE_FINAL_SIGKILL)
2542 return 0;
2543
f0c7b229 2544 /* A restart will be scheduled or is in progress. */
034c6ed7 2545 if (s->state == SERVICE_AUTO_RESTART) {
0c7f15b3 2546 service_set_state(s, SERVICE_DEAD);
034c6ed7
LP		 2547 return 0;
2548 }
2549
3f6c78dc
LP		 2550 /* If there's already something running we go directly into
2551 * kill mode. */
2552 if (s->state == SERVICE_START_PRE ||
2553 s->state == SERVICE_START ||
2554 s->state == SERVICE_START_POST ||
2555 s->state == SERVICE_RELOAD) {
f42806df 2556 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
3f6c78dc
LP		 2557 return 0;
2558 }
5cb5a6ff 2559
3f6c78dc
LP		 2560 assert(s->state == SERVICE_RUNNING ||
2561 s->state == SERVICE_EXITED);
3a762661 2562
f42806df 2563 service_enter_stop(s, SERVICE_SUCCESS);
5cb5a6ff
LP		 2564 return 0;
2565}
2566
87f0e418
LP		 2567static int service_reload(Unit *u) {
2568 Service *s = SERVICE(u);
034c6ed7
LP		 2569
2570 assert(s);
2571
80876c20 2572 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
034c6ed7
LP		 2573
2574 service_enter_reload(s);
5cb5a6ff
LP		 2575 return 0;
2576}
2577
44a6b1b6 2578_pure_ static bool service_can_reload(Unit *u) {
87f0e418 2579 Service *s = SERVICE(u);
034c6ed7
LP		 2580
2581 assert(s);
2582
2583 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2584}
2585
a16e1123
LP		 2586static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2587 Service *s = SERVICE(u);
2588
2589 assert(u);
2590 assert(f);
2591 assert(fds);
2592
2593 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
f42806df
LP		 2594 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2595 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
a16e1123
LP		 2596
2597 if (s->control_pid > 0)
117dcc57
ZJS		 2598 unit_serialize_item_format(u, f, "control-pid", "%lu",
2599 (unsigned long) s->control_pid);
a16e1123 2600
5925dd3c
LP		 2601 if (s->main_pid_known && s->main_pid > 0)
2602 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
a16e1123
LP		 2603
2604 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2605
3a2776bc
LP		 2606 if (s->status_text)
2607 unit_serialize_item(u, f, "status-text", s->status_text);
2608
cfc4eb4c
LP		 2609 /* FIXME: There's a minor uncleanliness here: if there are
2610 * multiple commands attached here, we will start from the
2611 * first one again */
a16e1123 2612 if (s->control_command_id >= 0)
117dcc57
ZJS		 2613 unit_serialize_item(u, f, "control-command",
2614 service_exec_command_to_string(s->control_command_id));
a16e1123
LP		 2615
2616 if (s->socket_fd >= 0) {
2617 int copy;
2618
2619 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2620 return copy;
2621
2622 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2623 }
2624
ecdbca40 2625 if (s->main_exec_status.pid > 0) {
117dcc57
ZJS		 2626 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2627 (unsigned long) s->main_exec_status.pid);
2628 dual_timestamp_serialize(f, "main-exec-status-start",
2629 &s->main_exec_status.start_timestamp);
2630 dual_timestamp_serialize(f, "main-exec-status-exit",
2631 &s->main_exec_status.exit_timestamp);
ecdbca40 2632
799fd0fd 2633 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
117dcc57
ZJS		 2634 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2635 s->main_exec_status.code);
2636 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2637 s->main_exec_status.status);
ecdbca40
LP		 2638 }
2639 }
a6927d7f 2640 if (dual_timestamp_is_set(&s->watchdog_timestamp))
117dcc57
ZJS		 2641 dual_timestamp_serialize(f, "watchdog-timestamp",
2642 &s->watchdog_timestamp);
ecdbca40 2643
c17ec25e
MS		 2644 if (s->exec_context.tmp_dir)
2645 unit_serialize_item(u, f, "tmp-dir", s->exec_context.tmp_dir);
2646
2647 if (s->exec_context.var_tmp_dir)
2648 unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2649
a16e1123
LP		 2650 return 0;
2651}
2652
2653static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2654 Service *s = SERVICE(u);
a16e1123
LP		 2655
2656 assert(u);
2657 assert(key);
2658 assert(value);
2659 assert(fds);
2660
2661 if (streq(key, "state")) {
2662 ServiceState state;
2663
117dcc57
ZJS		 2664 state = service_state_from_string(value);
2665 if (state < 0)
66870f90 2666 log_debug_unit(u->id, "Failed to parse state value %s", value);
a16e1123
LP		 2667 else
2668 s->deserialized_state = state;
f42806df
LP		 2669 } else if (streq(key, "result")) {
2670 ServiceResult f;
2671
2672 f = service_result_from_string(value);
2673 if (f < 0)
66870f90 2674 log_debug_unit(u->id, "Failed to parse result value %s", value);
f42806df
LP		 2675 else if (f != SERVICE_SUCCESS)
2676 s->result = f;
2677
2678 } else if (streq(key, "reload-result")) {
2679 ServiceResult f;
2680
2681 f = service_result_from_string(value);
2682 if (f < 0)
66870f90 2683 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
f42806df
LP		 2684 else if (f != SERVICE_SUCCESS)
2685 s->reload_result = f;
a16e1123 2686
a16e1123 2687 } else if (streq(key, "control-pid")) {
5925dd3c 2688 pid_t pid;
a16e1123 2689
e364ad06 2690 if (parse_pid(value, &pid) < 0)
66870f90 2691 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
a16e1123 2692 else
e55224ca 2693 s->control_pid = pid;
a16e1123 2694 } else if (streq(key, "main-pid")) {
5925dd3c 2695 pid_t pid;
a16e1123 2696
e364ad06 2697 if (parse_pid(value, &pid) < 0)
66870f90 2698 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
a16e1123 2699 else
5925dd3c 2700 service_set_main_pid(s, (pid_t) pid);
a16e1123
LP		 2701 } else if (streq(key, "main-pid-known")) {
2702 int b;
2703
117dcc57
ZJS		 2704 b = parse_boolean(value);
2705 if (b < 0)
66870f90 2706 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
a16e1123
LP		 2707 else
2708 s->main_pid_known = b;
3a2776bc
LP		 2709 } else if (streq(key, "status-text")) {
2710 char *t;
2711
117dcc57
ZJS		 2712 t = strdup(value);
2713 if (!t)
2714 log_oom();
2715 else {
3a2776bc
LP		 2716 free(s->status_text);
2717 s->status_text = t;
2718 }
2719
a16e1123
LP		 2720 } else if (streq(key, "control-command")) {
2721 ServiceExecCommand id;
2722
117dcc57
ZJS		 2723 id = service_exec_command_from_string(value);
2724 if (id < 0)
66870f90 2725 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
a16e1123
LP		 2726 else {
2727 s->control_command_id = id;
2728 s->control_command = s->exec_command[id];
2729 }
2730 } else if (streq(key, "socket-fd")) {
2731 int fd;
2732
2733 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
66870f90 2734 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
a16e1123
LP		 2735 else {
2736
2737 if (s->socket_fd >= 0)
2738 close_nointr_nofail(s->socket_fd);
2739 s->socket_fd = fdset_remove(fds, fd);
2740 }
ecdbca40
LP		 2741 } else if (streq(key, "main-exec-status-pid")) {
2742 pid_t pid;
2743
e364ad06 2744 if (parse_pid(value, &pid) < 0)
66870f90 2745 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
ecdbca40
LP		 2746 else
2747 s->main_exec_status.pid = pid;
2748 } else if (streq(key, "main-exec-status-code")) {
2749 int i;
2750
e364ad06 2751 if (safe_atoi(value, &i) < 0)
66870f90 2752 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
ecdbca40
LP		 2753 else
2754 s->main_exec_status.code = i;
2755 } else if (streq(key, "main-exec-status-status")) {
2756 int i;
2757
e364ad06 2758 if (safe_atoi(value, &i) < 0)
66870f90 2759 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
ecdbca40
LP		 2760 else
2761 s->main_exec_status.status = i;
799fd0fd
LP		 2762 } else if (streq(key, "main-exec-status-start"))
2763 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2764 else if (streq(key, "main-exec-status-exit"))
2765 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
a6927d7f
MO		 2766 else if (streq(key, "watchdog-timestamp"))
2767 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
c17ec25e
MS		 2768 else if (streq(key, "tmp-dir")) {
2769 char *t;
2770
2771 t = strdup(value);
2772 if (!t)
2773 return log_oom();
2774
2775 s->exec_context.tmp_dir = t;
2776 } else if (streq(key, "var-tmp-dir")) {
2777 char *t;
2778
2779 t = strdup(value);
2780 if (!t)
2781 return log_oom();
2782
2783 s->exec_context.var_tmp_dir = t;
2784 } else
66870f90 2785 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
a16e1123
LP		 2786
2787 return 0;
2788}
2789
44a6b1b6 2790_pure_ static UnitActiveState service_active_state(Unit *u) {
e056b01d
LP		 2791 const UnitActiveState *table;
2792
87f0e418 2793 assert(u);
5cb5a6ff 2794
e056b01d
LP		 2795 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2796
2797 return table[SERVICE(u)->state];
034c6ed7
LP		 2798}
2799
10a94420
LP		 2800static const char *service_sub_state_to_string(Unit *u) {
2801 assert(u);
2802
2803 return service_state_to_string(SERVICE(u)->state);
2804}
2805
701cc384
LP		 2806static bool service_check_gc(Unit *u) {
2807 Service *s = SERVICE(u);
2808
2809 assert(s);
2810
6d55002a
LP		 2811 /* Never clean up services that still have a process around,
2812 * even if the service is formally dead. */
2813 if (cgroup_good(s) > 0 ||
2814 main_pid_good(s) > 0 ||
2815 control_pid_good(s) > 0)
2816 return true;
2817
2818#ifdef HAVE_SYSV_COMPAT
1b64d026 2819 if (s->is_sysv)
6d55002a 2820 return true;
07459bb6 2821#endif
701cc384 2822
6d55002a
LP		 2823 return false;
2824}
2825
44a6b1b6 2826_pure_ static bool service_check_snapshot(Unit *u) {
701cc384
LP		 2827 Service *s = SERVICE(u);
2828
2829 assert(s);
2830
2831 return !s->got_socket_fd;
2832}
2833
3a111838
MS		 2834static int service_retry_pid_file(Service *s) {
2835 int r;
2836
2837 assert(s->pid_file);
2838 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2839
2840 r = service_load_pid_file(s, false);
2841 if (r < 0)
2842 return r;
2843
2844 service_unwatch_pid_file(s);
2845
f42806df 2846 service_enter_running(s, SERVICE_SUCCESS);
3a111838
MS		 2847 return 0;
2848}
2849
2850static int service_watch_pid_file(Service *s) {
2851 int r;
2852
66870f90
ZJS		 2853 log_debug_unit(UNIT(s)->id,
2854 "Setting watch for %s's PID file %s",
2855 UNIT(s)->id, s->pid_file_pathspec->path);
57020a3a 2856 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
3a111838
MS		 2857 if (r < 0)
2858 goto fail;
2859
2860 /* the pidfile might have appeared just before we set the watch */
bc41f93e
ZJS		 2861 log_debug_unit(UNIT(s)->id,
2862 "Trying to read %s's PID file %s in case it changed",
2863 UNIT(s)->id, s->pid_file_pathspec->path);
3a111838
MS		 2864 service_retry_pid_file(s);
2865
2866 return 0;
2867fail:
66870f90
ZJS		 2868 log_error_unit(UNIT(s)->id,
2869 "Failed to set a watch for %s's PID file %s: %s",
2870 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
3a111838
MS		 2871 service_unwatch_pid_file(s);
2872 return r;
2873}
2874
2875static int service_demand_pid_file(Service *s) {
2876 PathSpec *ps;
2877
2878 assert(s->pid_file);
2879 assert(!s->pid_file_pathspec);
2880
2881 ps = new0(PathSpec, 1);
2882 if (!ps)
2883 return -ENOMEM;
2884
2885 ps->path = strdup(s->pid_file);
2886 if (!ps->path) {
2887 free(ps);
2888 return -ENOMEM;
2889 }
2890
2891 path_kill_slashes(ps->path);
2892
2893 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2894 * keep their PID file open all the time. */
2895 ps->type = PATH_MODIFIED;
2896 ps->inotify_fd = -1;
2897
2898 s->pid_file_pathspec = ps;
2899
2900 return service_watch_pid_file(s);
2901}
2902
2903static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2904 Service *s = SERVICE(u);
2905
2906 assert(s);
2907 assert(fd >= 0);
2908 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2909 assert(s->pid_file_pathspec);
57020a3a 2910 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3a111838 2911
66870f90 2912 log_debug_unit(u->id, "inotify event for %s", u->id);
3a111838 2913
57020a3a 2914 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
3a111838
MS		 2915 goto fail;
2916
2917 if (service_retry_pid_file(s) == 0)
2918 return;
2919
2920 if (service_watch_pid_file(s) < 0)
2921 goto fail;
2922
2923 return;
2924fail:
2925 service_unwatch_pid_file(s);
f42806df 2926 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 2927}
2928
87f0e418
LP		 2929static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2930 Service *s = SERVICE(u);
f42806df 2931 ServiceResult f;
5cb5a6ff
LP		 2932
2933 assert(s);
034c6ed7
LP		 2934 assert(pid >= 0);
2935
96342de6
LN		 2936 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2937 is_clean_exit_lsb(code, status, &s->success_status))
f42806df
LP		 2938 f = SERVICE_SUCCESS;
2939 else if (code == CLD_EXITED)
2940 f = SERVICE_FAILURE_EXIT_CODE;
2941 else if (code == CLD_KILLED)
2942 f = SERVICE_FAILURE_SIGNAL;
2943 else if (code == CLD_DUMPED)
2944 f = SERVICE_FAILURE_CORE_DUMP;
d06dacd0 2945 else
cfc4eb4c 2946 assert_not_reached("Unknown code");
034c6ed7
LP		 2947
2948 if (s->main_pid == pid) {
db01f8b3
MS		 2949 /* Forking services may occasionally move to a new PID.
2950 * As long as they update the PID file before exiting the old
2951 * PID, they're fine. */
5375410b 2952 if (service_load_pid_file(s, false) == 0)
db01f8b3 2953 return;
034c6ed7 2954
034c6ed7 2955 s->main_pid = 0;
6ea832a2 2956 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
034c6ed7 2957
867b3b7d 2958 if (s->main_command) {
fbeefb45
LP		 2959 /* If this is not a forking service than the
2960 * main process got started and hence we copy
2961 * the exit status so that it is recorded both
2962 * as main and as control process exit
2963 * status */
2964
867b3b7d 2965 s->main_command->exec_status = s->main_exec_status;
b708e7ce 2966
867b3b7d 2967 if (s->main_command->ignore)
f42806df 2968 f = SERVICE_SUCCESS;
fbeefb45
LP		 2969 } else if (s->exec_command[SERVICE_EXEC_START]) {
2970
2971 /* If this is a forked process, then we should
2972 * ignore the return value if this was
2973 * configured for the starter process */
2974
2975 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2976 f = SERVICE_SUCCESS;
034c6ed7
LP		 2977 }
2978
bbc9006e
MT		 2979 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2980 u->id,
23635a85
ZJS		 2981 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2982 u->id, sigchld_code_to_string(code), status,
2983 strna(code == CLD_EXITED
2984 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2985 : signal_to_string(status)),
23635a85
ZJS		 2986 "EXIT_CODE=%s", sigchld_code_to_string(code),
2987 "EXIT_STATUS=%i", status,
2988 NULL);
f42806df
LP		 2989
2990 if (f != SERVICE_SUCCESS)
2991 s->result = f;
034c6ed7 2992
867b3b7d
LP		 2993 if (s->main_command &&
2994 s->main_command->command_next &&
f42806df 2995 f == SERVICE_SUCCESS) {
034c6ed7 2996
34e9ba66
LP		 2997 /* There is another command to *
2998 * execute, so let's do that. */
034c6ed7 2999
66870f90
ZJS		 3000 log_debug_unit(u->id,
3001 "%s running next main command for state %s",
3002 u->id, service_state_to_string(s->state));
f42806df 3003 service_run_next_main(s);
034c6ed7 3004
34e9ba66
LP		 3005 } else {
3006
3007 /* The service exited, so the service is officially
3008 * gone. */
867b3b7d 3009 s->main_command = NULL;
34e9ba66
LP		 3010
3011 switch (s->state) {
3012
3013 case SERVICE_START_POST:
3014 case SERVICE_RELOAD:
3015 case SERVICE_STOP:
3016 /* Need to wait until the operation is
3017 * done */
c4653a4d 3018 break;
7d55e835 3019
34e9ba66
LP		 3020 case SERVICE_START:
3021 if (s->type == SERVICE_ONESHOT) {
3022 /* This was our main goal, so let's go on */
f42806df 3023 if (f == SERVICE_SUCCESS)
34e9ba66
LP		 3024 service_enter_start_post(s);
3025 else
f42806df 3026 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
34e9ba66 3027 break;
34e9ba66 3028 }
034c6ed7 3029
bfba3256
LP		 3030 /* Fall through */
3031
34e9ba66 3032 case SERVICE_RUNNING:
f42806df 3033 service_enter_running(s, f);
34e9ba66 3034 break;
034c6ed7 3035
34e9ba66
LP		 3036 case SERVICE_STOP_SIGTERM:
3037 case SERVICE_STOP_SIGKILL:
5cb5a6ff 3038
34e9ba66 3039 if (!control_pid_good(s))
f42806df 3040 service_enter_stop_post(s, f);
5cb5a6ff 3041
34e9ba66
LP		 3042 /* If there is still a control process, wait for that first */
3043 break;
3044
3045 default:
3046 assert_not_reached("Uh, main process died at wrong time.");
3047 }
034c6ed7 3048 }
5cb5a6ff 3049
034c6ed7 3050 } else if (s->control_pid == pid) {
34e9ba66
LP		 3051 s->control_pid = 0;
3052
b708e7ce 3053 if (s->control_command) {
117dcc57
ZJS		 3054 exec_status_exit(&s->control_command->exec_status,
3055 &s->exec_context, pid, code, status);
a16e1123 3056
b708e7ce 3057 if (s->control_command->ignore)
f42806df 3058 f = SERVICE_SUCCESS;
b708e7ce
LP		 3059 }
3060
66870f90
ZJS		 3061 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3062 "%s: control process exited, code=%s status=%i",
3063 u->id, sigchld_code_to_string(code), status);
f42806df
LP		 3064
3065 if (f != SERVICE_SUCCESS)
3066 s->result = f;
034c6ed7 3067
88f3e0c9
LP		 3068 /* Immediately get rid of the cgroup, so that the
3069 * kernel doesn't delay the cgroup empty messages for
3070 * the service cgroup any longer than necessary */
4ad49000 3071 service_kill_control_processes(s);
88f3e0c9 3072
34e9ba66
LP		 3073 if (s->control_command &&
3074 s->control_command->command_next &&
f42806df 3075 f == SERVICE_SUCCESS) {
034c6ed7
LP		 3076
3077 /* There is another command to *
3078 * execute, so let's do that. */
3079
66870f90
ZJS		 3080 log_debug_unit(u->id,
3081 "%s running next control command for state %s",
3082 u->id, service_state_to_string(s->state));
f42806df 3083 service_run_next_control(s);
034c6ed7 3084
80876c20 3085 } else {
034c6ed7
LP		 3086 /* No further commands for this step, so let's
3087 * figure out what to do next */
3088
a16e1123
LP		 3089 s->control_command = NULL;
3090 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3091
66870f90
ZJS		 3092 log_debug_unit(u->id,
3093 "%s got final SIGCHLD for state %s",
3094 u->id, service_state_to_string(s->state));
bd982a8b 3095
034c6ed7
LP		 3096 switch (s->state) {
3097
3098 case SERVICE_START_PRE:
f42806df 3099 if (f == SERVICE_SUCCESS)
034c6ed7
LP		 3100 service_enter_start(s);
3101 else
f42806df 3102 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
034c6ed7
LP		 3103 break;
3104
3105 case SERVICE_START:
bfba3256
LP		 3106 if (s->type != SERVICE_FORKING)
3107 /* Maybe spurious event due to a reload that changed the type? */
3108 break;
034c6ed7 3109
f42806df
LP		 3110 if (f != SERVICE_SUCCESS) {
3111 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3a111838
MS		 3112 break;
3113 }
034c6ed7 3114
3a111838 3115 if (s->pid_file) {
f42806df
LP		 3116 bool has_start_post;
3117 int r;
3118
3a111838
MS		 3119 /* Let's try to load the pid file here if we can.
3120 * The PID file might actually be created by a START_POST
3121 * script. In that case don't worry if the loading fails. */
f42806df
LP		 3122
3123 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3124 r = service_load_pid_file(s, !has_start_post);
3a111838
MS		 3125 if (!has_start_post && r < 0) {
3126 r = service_demand_pid_file(s);
3127 if (r < 0 || !cgroup_good(s))
f42806df 3128 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3129 break;
3130 }
034c6ed7 3131 } else
3a111838 3132 service_search_main_pid(s);
034c6ed7 3133
3a111838 3134 service_enter_start_post(s);
034c6ed7
LP		 3135 break;
3136
3137 case SERVICE_START_POST:
f42806df
LP		 3138 if (f != SERVICE_SUCCESS) {
3139 service_enter_stop(s, f);
2096e009 3140 break;
034c6ed7
LP		 3141 }
3142
2096e009 3143 if (s->pid_file) {
f42806df
LP		 3144 int r;
3145
3146 r = service_load_pid_file(s, true);
2096e009
MS		 3147 if (r < 0) {
3148 r = service_demand_pid_file(s);
3149 if (r < 0 || !cgroup_good(s))
f42806df 3150 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2096e009
MS		 3151 break;
3152 }
3153 } else
3154 service_search_main_pid(s);
3155
f42806df 3156 service_enter_running(s, SERVICE_SUCCESS);
3185a36b 3157 break;
034c6ed7
LP		 3158
3159 case SERVICE_RELOAD:
f42806df 3160 if (f == SERVICE_SUCCESS) {
5375410b 3161 service_load_pid_file(s, true);
3185a36b
LP		 3162 service_search_main_pid(s);
3163 }
3164
f42806df
LP		 3165 s->reload_result = f;
3166 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 3167 break;
3168
3169 case SERVICE_STOP:
f42806df 3170 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
034c6ed7
LP		 3171 break;
3172
3173 case SERVICE_STOP_SIGTERM:
3174 case SERVICE_STOP_SIGKILL:
3175 if (main_pid_good(s) <= 0)
f42806df 3176 service_enter_stop_post(s, f);
034c6ed7
LP		 3177
3178 /* If there is still a service
3179 * process around, wait until
3180 * that one quit, too */
3181 break;
3182
3183 case SERVICE_STOP_POST:
3184 case SERVICE_FINAL_SIGTERM:
3185 case SERVICE_FINAL_SIGKILL:
f42806df 3186 service_enter_dead(s, f, true);
034c6ed7
LP		 3187 break;
3188
3189 default:
3190 assert_not_reached("Uh, control process died at wrong time.");
3191 }
3192 }
8c47c732 3193 }
c4e2ceae
LP		 3194
3195 /* Notify clients about changed exit status */
3196 unit_add_to_dbus_queue(u);
034c6ed7
LP		 3197}
3198
acbb0225 3199static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
87f0e418 3200 Service *s = SERVICE(u);
034c6ed7
LP		 3201
3202 assert(s);
3203 assert(elapsed == 1);
3204
bb242b7b
MO		 3205 if (w == &s->watchdog_watch) {
3206 service_handle_watchdog(s);
3207 return;
3208 }
3209
acbb0225 3210 assert(w == &s->timer_watch);
034c6ed7
LP		 3211
3212 switch (s->state) {
3213
3214 case SERVICE_START_PRE:
3215 case SERVICE_START:
66870f90
ZJS		 3216 log_warning_unit(u->id,
3217 "%s operation timed out. Terminating.", u->id);
f42806df 3218 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
80876c20
LP		 3219 break;
3220
034c6ed7 3221 case SERVICE_START_POST:
66870f90
ZJS		 3222 log_warning_unit(u->id,
3223 "%s operation timed out. Stopping.", u->id);
f42806df 3224 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3225 break;
3226
e2f3b44c 3227 case SERVICE_RELOAD:
66870f90
ZJS		 3228 log_warning_unit(u->id,
3229 "%s operation timed out. Stopping.", u->id);
f42806df
LP		 3230 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3231 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c
LP		 3232 break;
3233
034c6ed7 3234 case SERVICE_STOP:
66870f90
ZJS		 3235 log_warning_unit(u->id,
3236 "%s stopping timed out. Terminating.", u->id);
f42806df 3237 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3238 break;
3239
3240 case SERVICE_STOP_SIGTERM:
4819ff03 3241 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3242 log_warning_unit(u->id,
3243 "%s stopping timed out. Killing.", u->id);
f42806df 3244 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3245 } else {
66870f90
ZJS		 3246 log_warning_unit(u->id,
3247 "%s stopping timed out. Skipping SIGKILL.", u->id);
f42806df 3248 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
ba035df2
LP		 3249 }
3250
034c6ed7
LP		 3251 break;
3252
3253 case SERVICE_STOP_SIGKILL:
35b8ca3a 3254 /* Uh, we sent a SIGKILL and it is still not gone?
034c6ed7
LP		 3255 * Must be something we cannot kill, so let's just be
3256 * weirded out and continue */
3257
66870f90
ZJS		 3258 log_warning_unit(u->id,
3259 "%s still around after SIGKILL. Ignoring.", u->id);
f42806df 3260 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3261 break;
3262
3263 case SERVICE_STOP_POST:
66870f90
ZJS		 3264 log_warning_unit(u->id,
3265 "%s stopping timed out (2). Terminating.", u->id);
f42806df 3266 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3267 break;
3268
3269 case SERVICE_FINAL_SIGTERM:
4819ff03 3270 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3271 log_warning_unit(u->id,
3272 "%s stopping timed out (2). Killing.", u->id);
f42806df 3273 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3274 } else {
66870f90
ZJS		 3275 log_warning_unit(u->id,
3276 "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3277 u->id);
f42806df 3278 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
ba035df2
LP		 3279 }
3280
034c6ed7
LP		 3281 break;
3282
3283 case SERVICE_FINAL_SIGKILL:
66870f90
ZJS		 3284 log_warning_unit(u->id,
3285 "%s still around after SIGKILL (2). Entering failed mode.", u->id);
f42806df 3286 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
034c6ed7
LP		 3287 break;
3288
3289 case SERVICE_AUTO_RESTART:
66870f90
ZJS		 3290 log_info_unit(u->id,
3291 "%s holdoff time over, scheduling restart.", u->id);
034c6ed7
LP		 3292 service_enter_restart(s);
3293 break;
3294
3295 default:
3296 assert_not_reached("Timeout at wrong time.");
3297 }
5cb5a6ff
LP		 3298}
3299
4ad49000 3300static void service_notify_cgroup_empty_event(Unit *u) {
8e274523
LP		 3301 Service *s = SERVICE(u);
3302
3303 assert(u);
3304
6c12b52e 3305 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
8e274523
LP		 3306
3307 switch (s->state) {
3308
3309 /* Waiting for SIGCHLD is usually more interesting,
3310 * because it includes return codes/signals. Which is
3311 * why we ignore the cgroup events for most cases,
3312 * except when we don't know pid which to expect the
3313 * SIGCHLD for. */
3314
3a111838
MS		 3315 case SERVICE_START:
3316 case SERVICE_START_POST:
3317 /* If we were hoping for the daemon to write its PID file,
3318 * we can give up now. */
3319 if (s->pid_file_pathspec) {
66870f90
ZJS		 3320 log_warning_unit(u->id,
3321 "%s never wrote its PID file. Failing.", UNIT(s)->id);
3a111838
MS		 3322 service_unwatch_pid_file(s);
3323 if (s->state == SERVICE_START)
f42806df 3324 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838 3325 else
f42806df 3326 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3327 }
3328 break;
3329
8e274523 3330 case SERVICE_RUNNING:
f42806df
LP		 3331 /* service_enter_running() will figure out what to do */
3332 service_enter_running(s, SERVICE_SUCCESS);
8e274523
LP		 3333 break;
3334
28708d8a
LP		 3335 case SERVICE_STOP_SIGTERM:
3336 case SERVICE_STOP_SIGKILL:
6dfa5494 3337
28708d8a 3338 if (main_pid_good(s) <= 0 && !control_pid_good(s))
f42806df 3339 service_enter_stop_post(s, SERVICE_SUCCESS);
28708d8a
LP		 3340
3341 break;
3342
7f97f0fe
LP		 3343 case SERVICE_FINAL_SIGTERM:
3344 case SERVICE_FINAL_SIGKILL:
3345 if (main_pid_good(s) <= 0 && !control_pid_good(s))
e201a038 3346 service_enter_dead(s, SERVICE_SUCCESS, true);
7f97f0fe
LP		 3347
3348 break;
3349
8e274523
LP		 3350 default:
3351 ;
3352 }
3353}
3354
c952c6ec 3355static void service_notify_message(Unit *u, pid_t pid, char **tags) {
8c47c732
LP		 3356 Service *s = SERVICE(u);
3357 const char *e;
3358
3359 assert(u);
3360
c952c6ec 3361 if (s->notify_access == NOTIFY_NONE) {
66870f90
ZJS		 3362 log_warning_unit(u->id,
3363 "%s: Got notification message from PID %lu, but reception is disabled.",
3364 u->id, (unsigned long) pid);
c952c6ec
LP		 3365 return;
3366 }
3367
3368 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
66870f90
ZJS		 3369 log_warning_unit(u->id,
3370 "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3371 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
c952c6ec
LP		 3372 return;
3373 }
3374
66870f90
ZJS		 3375 log_debug_unit(u->id,
3376 "%s: Got message", u->id);
8c47c732
LP		 3377
3378 /* Interpret MAINPID= */
3379 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3380 (s->state == SERVICE_START ||
3381 s->state == SERVICE_START_POST ||
3382 s->state == SERVICE_RUNNING ||
3383 s->state == SERVICE_RELOAD)) {
8c47c732 3384
5925dd3c 3385 if (parse_pid(e + 8, &pid) < 0)
66870f90
ZJS		 3386 log_warning_unit(u->id,
3387 "Failed to parse notification message %s", e);
8c47c732 3388 else {
66870f90
ZJS		 3389 log_debug_unit(u->id,
3390 "%s: got %s", u->id, e);
5925dd3c 3391 service_set_main_pid(s, pid);
8c47c732
LP		 3392 }
3393 }
3394
3395 /* Interpret READY= */
3396 if (s->type == SERVICE_NOTIFY &&
3397 s->state == SERVICE_START &&
3398 strv_find(tags, "READY=1")) {
66870f90
ZJS		 3399 log_debug_unit(u->id,
3400 "%s: got READY=1", u->id);
8c47c732
LP		 3401
3402 service_enter_start_post(s);
3403 }
3404
3405 /* Interpret STATUS= */
7f110ff9
LP		 3406 e = strv_find_prefix(tags, "STATUS=");
3407 if (e) {
8c47c732
LP		 3408 char *t;
3409
3a2776bc 3410 if (e[7]) {
7f110ff9
LP		 3411
3412 if (!utf8_is_valid(e+7)) {
66870f90
ZJS		 3413 log_warning_unit(u->id,
3414 "Status message in notification is not UTF-8 clean.");
7f110ff9
LP		 3415 return;
3416 }
3417
3418 t = strdup(e+7);
3419 if (!t) {
66870f90
ZJS		 3420 log_error_unit(u->id,
3421 "Failed to allocate string.");
3a2776bc
LP		 3422 return;
3423 }
3424
66870f90
ZJS		 3425 log_debug_unit(u->id,
3426 "%s: got %s", u->id, e);
8c47c732 3427
3a2776bc
LP		 3428 free(s->status_text);
3429 s->status_text = t;
3430 } else {
3431 free(s->status_text);
3432 s->status_text = NULL;
3433 }
8c47c732 3434
8c47c732 3435 }
a6927d7f 3436 if (strv_find(tags, "WATCHDOG=1")) {
66870f90
ZJS		 3437 log_debug_unit(u->id,
3438 "%s: got WATCHDOG=1", u->id);
90527fbb
MO		 3439 if (dual_timestamp_is_set(&s->watchdog_timestamp))
3440 service_reset_watchdog(s);
a6927d7f 3441 }
c4e2ceae
LP		 3442
3443 /* Notify clients about changed status or main pid */
3444 unit_add_to_dbus_queue(u);
8c47c732
LP		 3445}
3446
07459bb6 3447#ifdef HAVE_SYSV_COMPAT
de3910a3 3448
2c4104f0 3449static int service_enumerate(Manager *m) {
2c4104f0
LP		 3450 char **p;
3451 unsigned i;
7fd1b19b
HH		 3452 _cleanup_closedir_ DIR *d = NULL;
3453 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
b92bea5d 3454 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
7fd1b19b 3455 _cleanup_set_free_ Set *shutdown_services = NULL;
c68364b7
LP		 3456 Unit *service;
3457 Iterator j;
2c4104f0
LP		 3458 int r;
3459
3460 assert(m);
3461
67445f4e 3462 if (m->running_as != SYSTEMD_SYSTEM)
b1bc08e5
LP		 3463 return 0;
3464
84e3543e 3465 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
09cd1ab1 3466 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
2c4104f0
LP		 3467 struct dirent *de;
3468
3469 free(path);
b7def684 3470 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
70132bd0 3471 if (!path) {
2c4104f0
LP		 3472 r = -ENOMEM;
3473 goto finish;
3474 }
3475
3476 if (d)
3477 closedir(d);
3478
117dcc57
ZJS		 3479 d = opendir(path);
3480 if (!d) {
2c4104f0 3481 if (errno != ENOENT)
117dcc57 3482 log_warning("opendir(%s) failed: %s", path, strerror(errno));
2c4104f0
LP		 3483
3484 continue;
3485 }
3486
3487 while ((de = readdir(d))) {
db06e3b6 3488 int a, b;
2c4104f0
LP		 3489
3490 if (ignore_file(de->d_name))
3491 continue;
3492
3493 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3494 continue;
3495
3496 if (strlen(de->d_name) < 4)
3497 continue;
3498
db06e3b6
LP		 3499 a = undecchar(de->d_name[1]);
3500 b = undecchar(de->d_name[2]);
3501
3502 if (a < 0 || b < 0)
3503 continue;
3504
2c4104f0 3505 free(fpath);
b7def684 3506 fpath = strjoin(path, "/", de->d_name, NULL);
8ea913b2 3507 if (!fpath) {
2c4104f0
LP		 3508 r = -ENOMEM;
3509 goto finish;
3510 }
3511
3512 if (access(fpath, X_OK) < 0) {
3513
3514 if (errno != ENOENT)
3515 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3516
3517 continue;
3518 }
3519
3520 free(name);
117dcc57
ZJS		 3521 name = sysv_translate_name(de->d_name + 3);
3522 if (!name) {
3523 r = log_oom();
2c4104f0
LP		 3524 goto finish;
3525 }
3526
66870f90
ZJS		 3527 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3528 if (r < 0) {
fbe9f3a9
LP		 3529 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3530 continue;
3531 }
2c4104f0 3532
c68364b7
LP		 3533 if (de->d_name[0] == 'S') {
3534
3cdebc21 3535 if (rcnd_table[i].type == RUNLEVEL_UP) {
ea87ca5a
LP		 3536 SERVICE(service)->sysv_start_priority_from_rcnd =
3537 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
db06e3b6 3538
c68364b7 3539 SERVICE(service)->sysv_enabled = true;
f73d93a4 3540 }
db06e3b6 3541
117dcc57
ZJS		 3542 r = set_ensure_allocated(&runlevel_services[i],
3543 trivial_hash_func, trivial_compare_func);
3544 if (r < 0)
c68364b7 3545 goto finish;
2c4104f0 3546
117dcc57
ZJS		 3547 r = set_put(runlevel_services[i], service);
3548 if (r < 0)
2c4104f0 3549 goto finish;
23a177ef 3550
fc5df99e 3551 } else if (de->d_name[0] == 'K' &&
3cdebc21 3552 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
6542952f 3553
117dcc57
ZJS		 3554 r = set_ensure_allocated(&shutdown_services,
3555 trivial_hash_func, trivial_compare_func);
3556 if (r < 0)
c68364b7
LP		 3557 goto finish;
3558
117dcc57
ZJS		 3559 r = set_put(shutdown_services, service);
3560 if (r < 0)
2c4104f0
LP		 3561 goto finish;
3562 }
3563 }
3564 }
3565
c68364b7
LP		 3566 /* Now we loaded all stubs and are aware of the lowest
3567 start-up priority for all services, not let's actually load
3568 the services, this will also tell us which services are
3569 actually native now */
3570 manager_dispatch_load_queue(m);
3571
3572 /* If this is a native service, rely on native ways to pull in
3573 * a service, don't pull it in via sysv rcN.d links. */
3574 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3575 SET_FOREACH(service, runlevel_services[i], j) {
3576 service = unit_follow_merge(service);
3577
ac155bb8 3578 if (service->fragment_path)
c68364b7
LP		 3579 continue;
3580
117dcc57
ZJS		 3581 r = unit_add_two_dependencies_by_name_inverse(
3582 service, UNIT_AFTER, UNIT_WANTS,
3583 rcnd_table[i].target, NULL, true);
3584 if (r < 0)
c68364b7
LP		 3585 goto finish;
3586 }
3587
3588 /* We honour K links only for halt/reboot. For the normal
3589 * runlevels we assume the stop jobs will be implicitly added
35b8ca3a 3590 * by the core logic. Also, we don't really distinguish here
c68364b7 3591 * between the runlevels 0 and 6 and just add them to the
3cdebc21 3592 * special shutdown target. */
c68364b7
LP		 3593 SET_FOREACH(service, shutdown_services, j) {
3594 service = unit_follow_merge(service);
3595
ac155bb8 3596 if (service->fragment_path)
c68364b7
LP		 3597 continue;
3598
117dcc57
ZJS		 3599 r = unit_add_two_dependencies_by_name(
3600 service, UNIT_BEFORE, UNIT_CONFLICTS,
3601 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3602 if (r < 0)
c68364b7
LP		 3603 goto finish;
3604 }
3605
2c4104f0
LP		 3606 r = 0;
3607
3608finish:
fbe9f3a9 3609
c68364b7
LP		 3610 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3611 set_free(runlevel_services[i]);
2c4104f0
LP		 3612
3613 return r;
3614}
07459bb6 3615#endif
2c4104f0 3616
05e343b7
LP		 3617static void service_bus_name_owner_change(
3618 Unit *u,
3619 const char *name,
3620 const char *old_owner,
3621 const char *new_owner) {
3622
3623 Service *s = SERVICE(u);
3624
3625 assert(s);
3626 assert(name);
3627
3628 assert(streq(s->bus_name, name));
3629 assert(old_owner || new_owner);
3630
3631 if (old_owner && new_owner)
66870f90
ZJS		 3632 log_debug_unit(u->id,
3633 "%s's D-Bus name %s changed owner from %s to %s",
3634 u->id, name, old_owner, new_owner);
05e343b7 3635 else if (old_owner)
66870f90
ZJS		 3636 log_debug_unit(u->id,
3637 "%s's D-Bus name %s no longer registered by %s",
3638 u->id, name, old_owner);
05e343b7 3639 else
66870f90
ZJS		 3640 log_debug_unit(u->id,
3641 "%s's D-Bus name %s now registered by %s",
3642 u->id, name, new_owner);
05e343b7
LP		 3643
3644 s->bus_name_good = !!new_owner;
3645
3646 if (s->type == SERVICE_DBUS) {
3647
3648 /* service_enter_running() will figure out what to
3649 * do */
3650 if (s->state == SERVICE_RUNNING)
f42806df 3651 service_enter_running(s, SERVICE_SUCCESS);
05e343b7
LP		 3652 else if (s->state == SERVICE_START && new_owner)
3653 service_enter_start_post(s);
3654
3655 } else if (new_owner &&
3656 s->main_pid <= 0 &&
3657 (s->state == SERVICE_START ||
3658 s->state == SERVICE_START_POST ||
3659 s->state == SERVICE_RUNNING ||
3660 s->state == SERVICE_RELOAD)) {
3661
3662 /* Try to acquire PID from bus service */
66870f90
ZJS		 3663 log_debug_unit(u->id,
3664 "Trying to acquire PID from D-Bus name...");
05e343b7 3665
ac155bb8 3666 bus_query_pid(u->manager, name);
05e343b7
LP		 3667 }
3668}
3669
3670static void service_bus_query_pid_done(
3671 Unit *u,
3672 const char *name,
3673 pid_t pid) {
3674
3675 Service *s = SERVICE(u);
3676
3677 assert(s);
3678 assert(name);
3679
66870f90
ZJS		 3680 log_debug_unit(u->id,
3681 "%s's D-Bus name %s is now owned by process %u",
3682 u->id, name, (unsigned) pid);
05e343b7
LP		 3683
3684 if (s->main_pid <= 0 &&
3685 (s->state == SERVICE_START ||
3686 s->state == SERVICE_START_POST ||
3687 s->state == SERVICE_RUNNING ||
3688 s->state == SERVICE_RELOAD))
5925dd3c 3689 service_set_main_pid(s, pid);
05e343b7
LP		 3690}
3691
6cf6bbc2 3692int service_set_socket_fd(Service *s, int fd, Socket *sock) {
57020a3a 3693
4f2d528d
LP		 3694 assert(s);
3695 assert(fd >= 0);
3696
3697 /* This is called by the socket code when instantiating a new
3698 * service for a stream socket and the socket needs to be
3699 * configured. */
3700
1124fe6f 3701 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 3702 return -EINVAL;
3703
3704 if (s->socket_fd >= 0)
3705 return -EBUSY;
3706
3707 if (s->state != SERVICE_DEAD)
3708 return -EAGAIN;
3709
3710 s->socket_fd = fd;
701cc384 3711 s->got_socket_fd = true;
6cf6bbc2 3712
57020a3a
LP		 3713 unit_ref_set(&s->accept_socket, UNIT(sock));
3714
3715 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
4f2d528d
LP		 3716}
3717
fdf20a31 3718static void service_reset_failed(Unit *u) {
5632e374
LP		 3719 Service *s = SERVICE(u);
3720
3721 assert(s);
3722
fdf20a31 3723 if (s->state == SERVICE_FAILED)
5632e374
LP		 3724 service_set_state(s, SERVICE_DEAD);
3725
f42806df
LP		 3726 s->result = SERVICE_SUCCESS;
3727 s->reload_result = SERVICE_SUCCESS;
451b34cc
LP		 3728
3729 RATELIMIT_RESET(s->start_limit);
5632e374
LP		 3730}
3731
c74f17d9 3732static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
8a0867d6 3733 Service *s = SERVICE(u);
41efeaec 3734
814cc562 3735 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
8a0867d6
LP		 3736}
3737
94f04347
LP		 3738static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3739 [SERVICE_DEAD] = "dead",
3740 [SERVICE_START_PRE] = "start-pre",
3741 [SERVICE_START] = "start",
3742 [SERVICE_START_POST] = "start-post",
3743 [SERVICE_RUNNING] = "running",
80876c20 3744 [SERVICE_EXITED] = "exited",
94f04347
LP		 3745 [SERVICE_RELOAD] = "reload",
3746 [SERVICE_STOP] = "stop",
3747 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3748 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3749 [SERVICE_STOP_POST] = "stop-post",
3750 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3751 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 3752 [SERVICE_FAILED] = "failed",
94f04347
LP		 3753 [SERVICE_AUTO_RESTART] = "auto-restart",
3754};
3755
3756DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3757
3758static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
525ee6f4
LP		 3759 [SERVICE_RESTART_NO] = "no",
3760 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
50caaedb 3761 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
dc99a976 3762 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
50caaedb
LP		 3763 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3764 [SERVICE_RESTART_ALWAYS] = "always"
94f04347
LP		 3765};
3766
3767DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3768
3769static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
94f04347 3770 [SERVICE_SIMPLE] = "simple",
0d624a78 3771 [SERVICE_FORKING] = "forking",
34e9ba66 3772 [SERVICE_ONESHOT] = "oneshot",
8c47c732 3773 [SERVICE_DBUS] = "dbus",
f2b68789
LP		 3774 [SERVICE_NOTIFY] = "notify",
3775 [SERVICE_IDLE] = "idle"
94f04347
LP		 3776};
3777
3778DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3779
e537352b 3780static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
94f04347
LP		 3781 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3782 [SERVICE_EXEC_START] = "ExecStart",
3783 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3784 [SERVICE_EXEC_RELOAD] = "ExecReload",
3785 [SERVICE_EXEC_STOP] = "ExecStop",
3786 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3787};
3788
3789DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3790
c952c6ec
LP		 3791static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3792 [NOTIFY_NONE] = "none",
3793 [NOTIFY_MAIN] = "main",
3794 [NOTIFY_ALL] = "all"
3795};
3796
3797DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3798
f42806df
LP		 3799static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3800 [SERVICE_SUCCESS] = "success",
3801 [SERVICE_FAILURE_RESOURCES] = "resources",
3802 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3803 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3804 [SERVICE_FAILURE_SIGNAL] = "signal",
bb242b7b 3805 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
8d1b002a
LP		 3806 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3807 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
f42806df
LP		 3808};
3809
3810DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3811
4b939747
MO		 3812static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3813 [SERVICE_START_LIMIT_NONE] = "none",
3814 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3815 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3816 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3817};
3818DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3819
87f0e418 3820const UnitVTable service_vtable = {
7d17cfbc 3821 .object_size = sizeof(Service),
3ef63c31 3822
f975e971
LP		 3823 .sections =
3824 "Unit\0"
3825 "Service\0"
3826 "Install\0",
5cb5a6ff 3827
4ad49000 3828 .private_section = "Service",
71645aca 3829 .exec_context_offset = offsetof(Service, exec_context),
4ad49000 3830 .cgroup_context_offset = offsetof(Service, cgroup_context),
71645aca 3831
034c6ed7
LP		 3832 .init = service_init,
3833 .done = service_done,
a16e1123
LP		 3834 .load = service_load,
3835
3836 .coldplug = service_coldplug,
034c6ed7 3837
5cb5a6ff
LP		 3838 .dump = service_dump,
3839
3840 .start = service_start,
3841 .stop = service_stop,
3842 .reload = service_reload,
3843
034c6ed7
LP		 3844 .can_reload = service_can_reload,
3845
8a0867d6
LP		 3846 .kill = service_kill,
3847
a16e1123
LP		 3848 .serialize = service_serialize,
3849 .deserialize_item = service_deserialize_item,
3850
5cb5a6ff 3851 .active_state = service_active_state,
10a94420 3852 .sub_state_to_string = service_sub_state_to_string,
5cb5a6ff 3853
701cc384
LP		 3854 .check_gc = service_check_gc,
3855 .check_snapshot = service_check_snapshot,
3856
034c6ed7
LP		 3857 .sigchld_event = service_sigchld_event,
3858 .timer_event = service_timer_event,
3a111838 3859 .fd_event = service_fd_event,
2c4104f0 3860
fdf20a31 3861 .reset_failed = service_reset_failed,
5632e374 3862
4ad49000 3863 .notify_cgroup_empty = service_notify_cgroup_empty_event,
8c47c732 3864 .notify_message = service_notify_message,
8e274523 3865
05e343b7
LP		 3866 .bus_name_owner_change = service_bus_name_owner_change,
3867 .bus_query_pid_done = service_bus_query_pid_done,
3868
c4e2ceae 3869 .bus_interface = "org.freedesktop.systemd1.Service",
4139c1b2 3870 .bus_message_handler = bus_service_message_handler,
c4e2ceae 3871 .bus_invalidating_properties = bus_service_invalidating_properties,
74c964d3
LP		 3872 .bus_set_property = bus_service_set_property,
3873 .bus_commit_properties = bus_service_commit_properties,
4139c1b2 3874
c2756a68
LP		 3875 .can_transient = true,
3876
07459bb6 3877#ifdef HAVE_SYSV_COMPAT
c6918296 3878 .enumerate = service_enumerate,
07459bb6 3879#endif
c6918296
MS		 3880 .status_message_formats = {
3881 .starting_stopping = {
3882 [0] = "Starting %s...",
3883 [1] = "Stopping %s...",
3884 },
3885 .finished_start_job = {
3886 [JOB_DONE] = "Started %s.",
3887 [JOB_FAILED] = "Failed to start %s.",
3888 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3889 [JOB_TIMEOUT] = "Timed out starting %s.",
3890 },
3891 .finished_stop_job = {
3892 [JOB_DONE] = "Stopped %s.",
3893 [JOB_FAILED] = "Stopped (with error) %s.",
3894 [JOB_TIMEOUT] = "Timed out stopping %s.",
3895 },
3896 },
5cb5a6ff 3897};
Unnamed repository; edit this file 'description' to name the repository.