]> 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
journald: remove unconditional log_*() use in the main loop
[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"
398ef8ba 39#include "bus-errors.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);
a16e1123 144
4b939747 145 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
a16e1123
LP		 146
147 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
148}
149
5e94833f
LP		 150static void service_unwatch_control_pid(Service *s) {
151 assert(s);
152
153 if (s->control_pid <= 0)
154 return;
155
156 unit_unwatch_pid(UNIT(s), s->control_pid);
157 s->control_pid = 0;
158}
159
160static void service_unwatch_main_pid(Service *s) {
161 assert(s);
162
163 if (s->main_pid <= 0)
164 return;
165
166 unit_unwatch_pid(UNIT(s), s->main_pid);
167 s->main_pid = 0;
168}
169
3e52541e
MS		 170static void service_unwatch_pid_file(Service *s) {
171 if (!s->pid_file_pathspec)
172 return;
173
66870f90
ZJS		 174 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
175 UNIT(s)->id, s->pid_file_pathspec->path);
3e52541e
MS		 176 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
177 path_spec_done(s->pid_file_pathspec);
178 free(s->pid_file_pathspec);
179 s->pid_file_pathspec = NULL;
180}
181
5925dd3c 182static int service_set_main_pid(Service *s, pid_t pid) {
e55224ca
LP		 183 pid_t ppid;
184
5925dd3c
LP		 185 assert(s);
186
187 if (pid <= 1)
188 return -EINVAL;
189
190 if (pid == getpid())
191 return -EINVAL;
192
6dfa5494
LP		 193 s->main_pid = pid;
194 s->main_pid_known = true;
195
196 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
66870f90
ZJS		 197 log_warning_unit(UNIT(s)->id,
198 "%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
199 UNIT(s)->id, (unsigned long) pid);
e55224ca 200
6dfa5494
LP		 201 s->main_pid_alien = true;
202 } else
203 s->main_pid_alien = false;
5925dd3c 204
b58b4116
LP		 205 exec_status_start(&s->main_exec_status, pid);
206
5925dd3c
LP		 207 return 0;
208}
209
4f2d528d
LP		 210static void service_close_socket_fd(Service *s) {
211 assert(s);
212
213 if (s->socket_fd < 0)
214 return;
215
216 close_nointr_nofail(s->socket_fd);
217 s->socket_fd = -1;
218}
219
6cf6bbc2
LP		 220static void service_connection_unref(Service *s) {
221 assert(s);
222
57020a3a 223 if (!UNIT_DEREF(s->accept_socket))
6cf6bbc2
LP		 224 return;
225
57020a3a
LP		 226 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
227 unit_ref_unset(&s->accept_socket);
6cf6bbc2
LP		 228}
229
a6927d7f
MO		 230static void service_stop_watchdog(Service *s) {
231 assert(s);
232
bb242b7b 233 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
a6927d7f
MO		 234 s->watchdog_timestamp.realtime = 0;
235 s->watchdog_timestamp.monotonic = 0;
236}
237
bb242b7b
MO		 238static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
239
240static void service_handle_watchdog(Service *s) {
241 usec_t offset;
242 int r;
243
244 assert(s);
245
246 if (s->watchdog_usec == 0)
247 return;
248
249 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
250 if (offset >= s->watchdog_usec) {
66870f90 251 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
bb242b7b
MO		 252 service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
253 return;
254 }
255
36697dc0 256 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->watchdog_usec - offset, &s->watchdog_watch);
bb242b7b 257 if (r < 0)
66870f90
ZJS		 258 log_warning_unit(UNIT(s)->id,
259 "%s failed to install watchdog timer: %s",
260 UNIT(s)->id, strerror(-r));
bb242b7b
MO		 261}
262
a6927d7f
MO		 263static void service_reset_watchdog(Service *s) {
264 assert(s);
265
266 dual_timestamp_get(&s->watchdog_timestamp);
bb242b7b 267 service_handle_watchdog(s);
a6927d7f
MO		 268}
269
87f0e418
LP		 270static void service_done(Unit *u) {
271 Service *s = SERVICE(u);
44d8db9e
LP		 272
273 assert(s);
274
275 free(s->pid_file);
276 s->pid_file = NULL;
277
07459bb6 278#ifdef HAVE_SYSV_COMPAT
8309400a
LP		 279 free(s->sysv_runlevels);
280 s->sysv_runlevels = NULL;
07459bb6 281#endif
8309400a 282
8c47c732
LP		 283 free(s->status_text);
284 s->status_text = NULL;
285
c17ec25e 286 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
e537352b 287 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
44d8db9e 288 s->control_command = NULL;
867b3b7d 289 s->main_command = NULL;
44d8db9e 290
96342de6
LN		 291 set_free(s->restart_ignore_status.code);
292 s->restart_ignore_status.code = NULL;
293 set_free(s->restart_ignore_status.signal);
294 s->restart_ignore_status.signal = NULL;
295
296 set_free(s->success_status.code);
297 s->success_status.code = NULL;
298 set_free(s->success_status.signal);
299 s->success_status.signal = NULL;
300
44d8db9e
LP		 301 /* This will leak a process, but at least no memory or any of
302 * our resources */
5e94833f
LP		 303 service_unwatch_main_pid(s);
304 service_unwatch_control_pid(s);
3e52541e 305 service_unwatch_pid_file(s);
44d8db9e 306
05e343b7 307 if (s->bus_name) {
ac155bb8 308 unit_unwatch_bus_name(u, s->bus_name);
05e343b7
LP		 309 free(s->bus_name);
310 s->bus_name = NULL;
311 }
312
4f2d528d 313 service_close_socket_fd(s);
6cf6bbc2 314 service_connection_unref(s);
4f2d528d 315
57020a3a 316 unit_ref_unset(&s->accept_socket);
f976f3f6 317
bb242b7b
MO		 318 service_stop_watchdog(s);
319
acbb0225 320 unit_unwatch_timer(u, &s->timer_watch);
44d8db9e
LP		 321}
322
07459bb6 323#ifdef HAVE_SYSV_COMPAT
b7ccee3c
LP		 324static char *sysv_translate_name(const char *name) {
325 char *r;
326
5d4caf56
LP		 327 r = new(char, strlen(name) + sizeof(".service"));
328 if (!r)
b7ccee3c
LP		 329 return NULL;
330
5b819198 331 if (endswith(name, ".sh"))
85a3fa0e 332 /* Drop .sh suffix */
5b819198 333 strcpy(stpcpy(r, name) - 3, ".service");
11dac832 334 else if (startswith(name, "rc."))
85a3fa0e 335 /* Drop rc. prefix */
65530632 336 strcpy(stpcpy(r, name + 3), ".service");
b7ccee3c 337 else
85a3fa0e 338 /* Normal init script name */
b7ccee3c
LP		 339 strcpy(stpcpy(r, name), ".service");
340
341 return r;
342}
343
ee95669f 344static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
2c4104f0 345
a7d3cc26
LP		 346 /* We silently ignore the $ prefix here. According to the LSB
347 * spec it simply indicates whether something is a
348 * standardized name or a distribution-specific one. Since we
349 * just follow what already exists and do not introduce new
350 * uses or names we don't care who introduced a new name. */
351
2c4104f0 352 static const char * const table[] = {
6464aa08 353 /* LSB defined facilities */
5d4caf56 354 "local_fs", NULL,
a7d3cc26
LP		 355 "network", SPECIAL_NETWORK_TARGET,
356 "named", SPECIAL_NSS_LOOKUP_TARGET,
357 "portmap", SPECIAL_RPCBIND_TARGET,
358 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
5d4caf56 359 "syslog", NULL,
4466194c 360 "time", SPECIAL_TIME_SYNC_TARGET,
2c4104f0
LP		 361 };
362
363 unsigned i;
364 char *r;
ee95669f 365 const char *n;
2c4104f0 366
ee95669f
LP		 367 assert(name);
368 assert(_r);
a7d3cc26 369
ee95669f 370 n = *name == '$' ? name + 1 : name;
a7d3cc26 371
ee95669f 372 for (i = 0; i < ELEMENTSOF(table); i += 2) {
a7d3cc26 373
ee95669f
LP		 374 if (!streq(table[i], n))
375 continue;
2c4104f0 376
ee95669f
LP		 377 if (!table[i+1])
378 return 0;
379
5d4caf56
LP		 380 r = strdup(table[i+1]);
381 if (!r)
382 return log_oom();
ee95669f
LP		 383
384 goto finish;
385 }
2c4104f0 386
a7d3cc26 387 /* If we don't know this name, fallback heuristics to figure
0003d1ab 388 * out whether something is a target or a service alias. */
a7d3cc26 389
e83c7c0b
LP		 390 if (*name == '$') {
391 if (!unit_prefix_is_valid(n))
392 return -EINVAL;
393
ee95669f
LP		 394 /* Facilities starting with $ are most likely targets */
395 r = unit_name_build(n, NULL, ".target");
e83c7c0b 396 } else if (filename && streq(name, filename))
35b8ca3a 397 /* Names equaling the file name of the services are redundant */
ee95669f 398 return 0;
32159d3a 399 else
ee95669f
LP		 400 /* Everything else we assume to be normal service names */
401 r = sysv_translate_name(n);
2c4104f0 402
32159d3a 403 if (!r)
2c4104f0
LP		 404 return -ENOMEM;
405
406finish:
b4353094 407 *_r = r;
2c4104f0
LP		 408
409 return 1;
410}
411
56d748b4 412static int sysv_fix_order(Service *s) {
ac155bb8 413 Unit *other;
2c4104f0
LP		 414 int r;
415
416 assert(s);
417
418 if (s->sysv_start_priority < 0)
419 return 0;
420
23a177ef
LP		 421 /* For each pair of services where at least one lacks a LSB
422 * header, we use the start priority value to order things. */
2c4104f0 423
1124fe6f 424 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
2c4104f0
LP		 425 Service *t;
426 UnitDependency d;
eeaafddc 427 bool special_s, special_t;
2c4104f0 428
595ed347 429 t = SERVICE(other);
2c4104f0
LP		 430
431 if (s == t)
432 continue;
9f151f29 433
1124fe6f 434 if (UNIT(t)->load_state != UNIT_LOADED)
9f151f29 435 continue;
2c4104f0
LP		 436
437 if (t->sysv_start_priority < 0)
438 continue;
439
51a1a79d
LP		 440 /* If both units have modern headers we don't care
441 * about the priorities */
1124fe6f
MS		 442 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
443 (UNIT(t)->fragment_path || t->sysv_has_lsb))
23a177ef
LP		 444 continue;
445
eeaafddc
LP		 446 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
447 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
448
449 if (special_t && !special_s)
450 d = UNIT_AFTER;
451 else if (special_s && !special_t)
452 d = UNIT_BEFORE;
453 else if (t->sysv_start_priority < s->sysv_start_priority)
2c4104f0
LP		 454 d = UNIT_AFTER;
455 else if (t->sysv_start_priority > s->sysv_start_priority)
456 d = UNIT_BEFORE;
457 else
458 continue;
459
460 /* FIXME: Maybe we should compare the name here lexicographically? */
461
da19d5c1 462 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
2c4104f0
LP		 463 return r;
464 }
465
466 return 0;
467}
468
469static ExecCommand *exec_command_new(const char *path, const char *arg1) {
470 ExecCommand *c;
471
472 if (!(c = new0(ExecCommand, 1)))
473 return NULL;
474
475 if (!(c->path = strdup(path))) {
476 free(c);
477 return NULL;
478 }
479
480 if (!(c->argv = strv_new(path, arg1, NULL))) {
481 free(c->path);
482 free(c);
483 return NULL;
484 }
485
486 return c;
487}
488
37e2941d 489static int sysv_exec_commands(Service *s, const bool supports_reload) {
2c4104f0
LP		 490 ExecCommand *c;
491
492 assert(s);
1b64d026
LP		 493 assert(s->is_sysv);
494 assert(UNIT(s)->source_path);
2c4104f0 495
1b64d026
LP		 496 c = exec_command_new(UNIT(s)->source_path, "start");
497 if (!c)
2c4104f0
LP		 498 return -ENOMEM;
499 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
500
1b64d026
LP		 501 c = exec_command_new(UNIT(s)->source_path, "stop");
502 if (!c)
2c4104f0
LP		 503 return -ENOMEM;
504 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
505
37e2941d
MS		 506 if (supports_reload) {
507 c = exec_command_new(UNIT(s)->source_path, "reload");
508 if (!c)
509 return -ENOMEM;
510 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
511 }
2c4104f0
LP		 512
513 return 0;
514}
515
37e2941d
MS		 516static bool usage_contains_reload(const char *line) {
517 return (strcasestr(line, "{reload|") ||
518 strcasestr(line, "{reload}") ||
519 strcasestr(line, "{reload\"") ||
520 strcasestr(line, "|reload|") ||
521 strcasestr(line, "|reload}") ||
522 strcasestr(line, "|reload\""));
523}
524
e537352b 525static int service_load_sysv_path(Service *s, const char *path) {
2c4104f0
LP		 526 FILE *f;
527 Unit *u;
528 unsigned line = 0;
529 int r;
530 enum {
531 NORMAL,
532 DESCRIPTION,
533 LSB,
37e2941d
MS		 534 LSB_DESCRIPTION,
535 USAGE_CONTINUATION
2c4104f0 536 } state = NORMAL;
0b5d26f9 537 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
5f4b19f4 538 struct stat st;
37e2941d 539 bool supports_reload = false;
23a177ef
LP		 540
541 assert(s);
542 assert(path);
2c4104f0
LP		 543
544 u = UNIT(s);
545
1b64d026
LP		 546 f = fopen(path, "re");
547 if (!f) {
2c4104f0
LP		 548 r = errno == ENOENT ? 0 : -errno;
549 goto finish;
550 }
551
5f4b19f4
LP		 552 if (fstat(fileno(f), &st) < 0) {
553 r = -errno;
554 goto finish;
555 }
556
1b64d026
LP		 557 free(u->source_path);
558 u->source_path = strdup(path);
559 if (!u->source_path) {
2c4104f0
LP		 560 r = -ENOMEM;
561 goto finish;
562 }
1b64d026 563 u->source_mtime = timespec_load(&st.st_mtim);
5f4b19f4
LP		 564
565 if (null_or_empty(&st)) {
ac155bb8 566 u->load_state = UNIT_MASKED;
5f4b19f4
LP		 567 r = 0;
568 goto finish;
569 }
570
1b64d026
LP		 571 s->is_sysv = true;
572
2c4104f0
LP		 573 while (!feof(f)) {
574 char l[LINE_MAX], *t;
575
576 if (!fgets(l, sizeof(l), f)) {
577 if (feof(f))
578 break;
579
580 r = -errno;
66870f90
ZJS		 581 log_error_unit(u->id,
582 "Failed to read configuration file '%s': %s",
583 path, strerror(-r));
2c4104f0
LP		 584 goto finish;
585 }
586
587 line++;
588
589 t = strstrip(l);
37e2941d
MS		 590 if (*t != '#') {
591 /* Try to figure out whether this init script supports
592 * the reload operation. This heuristic looks for
593 * "Usage" lines which include the reload option. */
594 if ( state == USAGE_CONTINUATION ||
595 (state == NORMAL && strcasestr(t, "usage"))) {
596 if (usage_contains_reload(t)) {
597 supports_reload = true;
598 state = NORMAL;
599 } else if (t[strlen(t)-1] == '\\')
600 state = USAGE_CONTINUATION;
601 else
602 state = NORMAL;
603 }
604
2c4104f0 605 continue;
37e2941d 606 }
2c4104f0
LP		 607
608 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
609 state = LSB;
23a177ef 610 s->sysv_has_lsb = true;
2c4104f0
LP		 611 continue;
612 }
613
614 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
615 state = NORMAL;
616 continue;
617 }
618
619 t++;
620 t += strspn(t, WHITESPACE);
621
622 if (state == NORMAL) {
623
624 /* Try to parse Red Hat style chkconfig headers */
625
c2b35af6 626 if (startswith_no_case(t, "chkconfig:")) {
2c4104f0 627 int start_priority;
8309400a 628 char runlevels[16], *k;
2c4104f0
LP		 629
630 state = NORMAL;
631
8309400a
LP		 632 if (sscanf(t+10, "%15s %i %*i",
633 runlevels,
634 &start_priority) != 2) {
2c4104f0 635
66870f90
ZJS		 636 log_warning_unit(u->id,
637 "[%s:%u] Failed to parse chkconfig line. Ignoring.",
638 path, line);
2c4104f0
LP		 639 continue;
640 }
641
fbe9f3a9
LP		 642 /* A start priority gathered from the
643 * symlink farms is preferred over the
644 * data from the LSB header. */
8309400a 645 if (start_priority < 0 || start_priority > 99)
66870f90
ZJS		 646 log_warning_unit(u->id,
647 "[%s:%u] Start priority out of range. Ignoring.",
648 path, line);
ea87ca5a 649 else
8309400a
LP		 650 s->sysv_start_priority = start_priority;
651
652 char_array_0(runlevels);
653 k = delete_chars(runlevels, WHITESPACE "-");
654
655 if (k[0]) {
656 char *d;
657
658 if (!(d = strdup(k))) {
659 r = -ENOMEM;
660 goto finish;
661 }
662
663 free(s->sysv_runlevels);
664 s->sysv_runlevels = d;
2c4104f0
LP		 665 }
666
0b5d26f9 667 } else if (startswith_no_case(t, "description:")) {
2c4104f0
LP		 668
669 size_t k = strlen(t);
670 char *d;
0b5d26f9 671 const char *j;
2c4104f0
LP		 672
673 if (t[k-1] == '\\') {
674 state = DESCRIPTION;
675 t[k-1] = 0;
676 }
677
0b5d26f9
LP		 678 if ((j = strstrip(t+12)) && *j) {
679 if (!(d = strdup(j))) {
680 r = -ENOMEM;
681 goto finish;
682 }
683 } else
684 d = NULL;
2c4104f0 685
0b5d26f9
LP		 686 free(chkconfig_description);
687 chkconfig_description = d;
2c4104f0 688
c2b35af6 689 } else if (startswith_no_case(t, "pidfile:")) {
2c4104f0
LP		 690
691 char *fn;
692
693 state = NORMAL;
694
695 fn = strstrip(t+8);
696 if (!path_is_absolute(fn)) {
66870f90
ZJS		 697 log_warning_unit(u->id,
698 "[%s:%u] PID file not absolute. Ignoring.",
699 path, line);
2c4104f0
LP		 700 continue;
701 }
702
703 if (!(fn = strdup(fn))) {
704 r = -ENOMEM;
705 goto finish;
706 }
707
708 free(s->pid_file);
709 s->pid_file = fn;
710 }
711
712 } else if (state == DESCRIPTION) {
713
714 /* Try to parse Red Hat style description
715 * continuation */
716
717 size_t k = strlen(t);
0b5d26f9 718 char *j;
2c4104f0
LP		 719
720 if (t[k-1] == '\\')
721 t[k-1] = 0;
722 else
723 state = NORMAL;
724
0b5d26f9
LP		 725 if ((j = strstrip(t)) && *j) {
726 char *d = NULL;
727
728 if (chkconfig_description)
b7def684 729 d = strjoin(chkconfig_description, " ", j, NULL);
0b5d26f9
LP		 730 else
731 d = strdup(j);
2c4104f0 732
0b5d26f9
LP		 733 if (!d) {
734 r = -ENOMEM;
735 goto finish;
736 }
737
738 free(chkconfig_description);
739 chkconfig_description = d;
740 }
2c4104f0
LP		 741
742 } else if (state == LSB || state == LSB_DESCRIPTION) {
743
c2b35af6 744 if (startswith_no_case(t, "Provides:")) {
2c4104f0
LP		 745 char *i, *w;
746 size_t z;
747
748 state = LSB;
749
f60f22df 750 FOREACH_WORD_QUOTED(w, z, t+9, i) {
2c4104f0
LP		 751 char *n, *m;
752
753 if (!(n = strndup(w, z))) {
754 r = -ENOMEM;
755 goto finish;
756 }
757
9eb977db 758 r = sysv_translate_facility(n, path_get_file_name(path), &m);
2c4104f0
LP		 759 free(n);
760
761 if (r < 0)
762 goto finish;
763
764 if (r == 0)
765 continue;
766
bd77d0fc
LP		 767 if (unit_name_to_type(m) == UNIT_SERVICE)
768 r = unit_add_name(u, m);
9700edb4
LP		 769 else
770 /* NB: SysV targets
771 * which are provided
772 * by a service are
773 * pulled in by the
774 * services, as an
775 * indication that the
776 * generic service is
777 * now available. This
778 * is strictly
779 * one-way. The
780 * targets do NOT pull
781 * in the SysV
782 * services! */
783 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
bd77d0fc 784
2c4104f0 785 if (r < 0)
66870f90
ZJS		 786 log_error_unit(u->id,
787 "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
788 path, line, m, strerror(-r));
42a097a2
LP		 789
790 free(m);
2c4104f0
LP		 791 }
792
c2b35af6
LP		 793 } else if (startswith_no_case(t, "Required-Start:") ||
794 startswith_no_case(t, "Should-Start:") ||
795 startswith_no_case(t, "X-Start-Before:") ||
796 startswith_no_case(t, "X-Start-After:")) {
2c4104f0
LP		 797 char *i, *w;
798 size_t z;
799
800 state = LSB;
801
f60f22df 802 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
2c4104f0
LP		 803 char *n, *m;
804
805 if (!(n = strndup(w, z))) {
806 r = -ENOMEM;
807 goto finish;
808 }
809
9eb977db 810 r = sysv_translate_facility(n, path_get_file_name(path), &m);
e83c7c0b 811 if (r < 0) {
66870f90
ZJS		 812 log_error_unit(u->id,
813 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
814 path, line, n, strerror(-r));
e83c7c0b
LP		 815 free(n);
816 continue;
817 }
818
819 free(n);
2c4104f0
LP		 820
821 if (r == 0)
822 continue;
823
c2b35af6 824 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
2c4104f0
LP		 825
826 if (r < 0)
66870f90
ZJS		 827 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
828 path, line, m, strerror(-r));
42a097a2
LP		 829
830 free(m);
2c4104f0 831 }
c2b35af6 832 } else if (startswith_no_case(t, "Default-Start:")) {
8309400a
LP		 833 char *k, *d;
834
835 state = LSB;
836
837 k = delete_chars(t+14, WHITESPACE "-");
838
839 if (k[0] != 0) {
840 if (!(d = strdup(k))) {
841 r = -ENOMEM;
842 goto finish;
843 }
844
845 free(s->sysv_runlevels);
846 s->sysv_runlevels = d;
847 }
2c4104f0 848
0b5d26f9
LP		 849 } else if (startswith_no_case(t, "Description:")) {
850 char *d, *j;
ed4c1cc6 851
2c4104f0
LP		 852 state = LSB_DESCRIPTION;
853
0b5d26f9
LP		 854 if ((j = strstrip(t+12)) && *j) {
855 if (!(d = strdup(j))) {
856 r = -ENOMEM;
857 goto finish;
858 }
859 } else
860 d = NULL;
2c4104f0 861
0b5d26f9
LP		 862 free(long_description);
863 long_description = d;
2c4104f0 864
ed4c1cc6 865 } else if (startswith_no_case(t, "Short-Description:")) {
0b5d26f9 866 char *d, *j;
2c4104f0 867
2c4104f0
LP		 868 state = LSB;
869
0b5d26f9
LP		 870 if ((j = strstrip(t+18)) && *j) {
871 if (!(d = strdup(j))) {
872 r = -ENOMEM;
873 goto finish;
874 }
875 } else
876 d = NULL;
2c4104f0 877
0b5d26f9
LP		 878 free(short_description);
879 short_description = d;
2c4104f0
LP		 880
881 } else if (state == LSB_DESCRIPTION) {
882
883 if (startswith(l, "#\t") || startswith(l, "# ")) {
0b5d26f9 884 char *j;
2c4104f0 885
0b5d26f9
LP		 886 if ((j = strstrip(t)) && *j) {
887 char *d = NULL;
888
889 if (long_description)
b7def684 890 d = strjoin(long_description, " ", t, NULL);
0b5d26f9
LP		 891 else
892 d = strdup(j);
893
894 if (!d) {
895 r = -ENOMEM;
896 goto finish;
897 }
898
899 free(long_description);
900 long_description = d;
2c4104f0
LP		 901 }
902
2c4104f0
LP		 903 } else
904 state = LSB;
905 }
906 }
907 }
908
37e2941d 909 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
2c4104f0
LP		 910 goto finish;
911
a40eb732 912 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
0bc824be
LP		 913 /* If there a runlevels configured for this service
914 * but none of the standard ones, then we assume this
915 * is some special kind of service (which might be
916 * needed for early boot) and don't create any links
917 * to it. */
918
1124fe6f 919 UNIT(s)->default_dependencies = false;
09cd1ab1 920
09cd1ab1 921 /* Don't timeout special services during boot (like fsck) */
d568a335
MS		 922 s->timeout_start_usec = 0;
923 s->timeout_stop_usec = 0;
924 } else {
925 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
926 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
927 }
928
80876c20 929 /* Special setting for all SysV services */
1f48cf56 930 s->type = SERVICE_FORKING;
f8788303 931 s->remain_after_exit = !s->pid_file;
1835f23c 932 s->guess_main_pid = false;
525ee6f4 933 s->restart = SERVICE_RESTART_NO;
353e12c2 934 s->exec_context.ignore_sigpipe = false;
4819ff03 935 s->kill_context.kill_mode = KILL_PROCESS;
80876c20 936
0b5d26f9
LP		 937 /* We use the long description only if
938 * no short description is set. */
939
940 if (short_description)
941 description = short_description;
942 else if (chkconfig_description)
943 description = chkconfig_description;
944 else if (long_description)
945 description = long_description;
946 else
947 description = NULL;
948
949 if (description) {
950 char *d;
951
e527618d 952 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
0b5d26f9
LP		 953 r = -ENOMEM;
954 goto finish;
955 }
956
ac155bb8 957 u->description = d;
0b5d26f9
LP		 958 }
959
ea87ca5a
LP		 960 /* The priority that has been set in /etc/rcN.d/ hierarchies
961 * takes precedence over what is stored as default in the LSB
962 * header */
963 if (s->sysv_start_priority_from_rcnd >= 0)
964 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
965
ac155bb8 966 u->load_state = UNIT_LOADED;
23a177ef 967 r = 0;
2c4104f0
LP		 968
969finish:
970
971 if (f)
972 fclose(f);
973
0b5d26f9
LP		 974 free(short_description);
975 free(long_description);
976 free(chkconfig_description);
977
2c4104f0
LP		 978 return r;
979}
980
e537352b 981static int service_load_sysv_name(Service *s, const char *name) {
2c4104f0
LP		 982 char **p;
983
984 assert(s);
985 assert(name);
986
3cdebc21 987 /* For SysV services we strip the rc.* and *.sh
d017c6ca 988 * prefixes/suffixes. */
a83ad683
ZJS		 989 if (startswith(name, "rc.") ||
990 endswith(name, ".sh.service"))
d017c6ca
LP		 991 return -ENOENT;
992
1124fe6f 993 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
2c4104f0
LP		 994 char *path;
995 int r;
996
b7def684 997 path = strjoin(*p, "/", name, NULL);
44d91056 998 if (!path)
2c4104f0
LP		 999 return -ENOMEM;
1000
1001 assert(endswith(path, ".service"));
1002 path[strlen(path)-8] = 0;
1003
e537352b 1004 r = service_load_sysv_path(s, path);
fbe9f3a9 1005
1124fe6f 1006 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
20771ae3 1007 /* Try *.sh source'able init scripts */
fbe9f3a9
LP		 1008 strcat(path, ".sh");
1009 r = service_load_sysv_path(s, path);
1010 }
2c4104f0
LP		 1011 free(path);
1012
1124fe6f 1013 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
20771ae3 1014 /* Try rc.* init scripts */
65530632 1015
b7def684 1016 path = strjoin(*p, "/rc.", name, NULL);
44d91056 1017 if (!path)
65530632
MV		 1018 return -ENOMEM;
1019
e1992852 1020 /* Drop .service suffix */
65530632
MV		 1021 path[strlen(path)-8] = 0;
1022 r = service_load_sysv_path(s, path);
1023 free(path);
1024 }
1025
23a177ef 1026 if (r < 0)
2c4104f0 1027 return r;
23a177ef 1028
88516c0c 1029 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef 1030 break;
2c4104f0
LP		 1031 }
1032
1033 return 0;
1034}
1035
e537352b 1036static int service_load_sysv(Service *s) {
2c4104f0
LP		 1037 const char *t;
1038 Iterator i;
1039 int r;
1040
5cb5a6ff
LP		 1041 assert(s);
1042
1043 /* Load service data from SysV init scripts, preferably with
1044 * LSB headers ... */
1045
1124fe6f 1046 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
2c4104f0
LP		 1047 return 0;
1048
1124fe6f 1049 if ((t = UNIT(s)->id))
e537352b 1050 if ((r = service_load_sysv_name(s, t)) < 0)
2c4104f0
LP		 1051 return r;
1052
1124fe6f
MS		 1053 if (UNIT(s)->load_state == UNIT_STUB)
1054 SET_FOREACH(t, UNIT(s)->names, i) {
1055 if (t == UNIT(s)->id)
e537352b
LP		 1056 continue;
1057
e364ad06 1058 if ((r = service_load_sysv_name(s, t)) < 0)
23a177ef
LP		 1059 return r;
1060
1124fe6f 1061 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef
LP		 1062 break;
1063 }
2c4104f0
LP		 1064
1065 return 0;
5cb5a6ff 1066}
07459bb6 1067#endif
5cb5a6ff 1068
9fff8a1f 1069static int fsck_fix_order(Service *s) {
ac155bb8 1070 Unit *other;
9fff8a1f
LP		 1071 int r;
1072
1073 assert(s);
1074
1075 if (s->fsck_passno <= 0)
1076 return 0;
1077
1078 /* For each pair of services where both have an fsck priority
1079 * we order things based on it. */
1080
1124fe6f 1081 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
9fff8a1f
LP		 1082 Service *t;
1083 UnitDependency d;
1084
595ed347 1085 t = SERVICE(other);
9fff8a1f
LP		 1086
1087 if (s == t)
1088 continue;
1089
1124fe6f 1090 if (UNIT(t)->load_state != UNIT_LOADED)
9fff8a1f
LP		 1091 continue;
1092
1093 if (t->fsck_passno <= 0)
1094 continue;
1095
1096 if (t->fsck_passno < s->fsck_passno)
1097 d = UNIT_AFTER;
1098 else if (t->fsck_passno > s->fsck_passno)
1099 d = UNIT_BEFORE;
1100 else
1101 continue;
1102
117dcc57
ZJS		 1103 r = unit_add_dependency(UNIT(s), d, UNIT(t), true);
1104 if (r < 0)
9fff8a1f
LP		 1105 return r;
1106 }
1107
1108 return 0;
1109}
1110
243b1432
LP		 1111static int service_verify(Service *s) {
1112 assert(s);
1113
1124fe6f 1114 if (UNIT(s)->load_state != UNIT_LOADED)
243b1432
LP		 1115 return 0;
1116
1117 if (!s->exec_command[SERVICE_EXEC_START]) {
66870f90
ZJS		 1118 log_error_unit(UNIT(s)->id,
1119 "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
243b1432
LP		 1120 return -EINVAL;
1121 }
1122
34e9ba66
LP		 1123 if (s->type != SERVICE_ONESHOT &&
1124 s->exec_command[SERVICE_EXEC_START]->command_next) {
66870f90
ZJS		 1125 log_error_unit(UNIT(s)->id,
1126 "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
6cf6bbc2
LP		 1127 return -EINVAL;
1128 }
1129
05e343b7 1130 if (s->type == SERVICE_DBUS && !s->bus_name) {
66870f90
ZJS		 1131 log_error_unit(UNIT(s)->id,
1132 "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
4d0e5dbd
LP		 1133 return -EINVAL;
1134 }
1135
7e2668c6 1136 if (s->bus_name && s->type != SERVICE_DBUS)
66870f90
ZJS		 1137 log_warning_unit(UNIT(s)->id,
1138 "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
7e2668c6 1139
4819ff03 1140 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
66870f90
ZJS		 1141 log_error_unit(UNIT(s)->id,
1142 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
05e343b7
LP		 1143 return -EINVAL;
1144 }
1145
243b1432
LP		 1146 return 0;
1147}
1148
a40eb732
LP		 1149static int service_add_default_dependencies(Service *s) {
1150 int r;
1151
1152 assert(s);
1153
1154 /* Add a number of automatic dependencies useful for the
1155 * majority of services. */
1156
1157 /* First, pull in base system */
67445f4e 1158 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
117dcc57
ZJS		 1159 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1160 SPECIAL_BASIC_TARGET, NULL, true);
1161 if (r < 0)
a40eb732
LP		 1162 return r;
1163
67445f4e 1164 } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
117dcc57
ZJS		 1165 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1166 SPECIAL_SOCKETS_TARGET, NULL, true);
1167 if (r < 0)
a40eb732
LP		 1168 return r;
1169 }
1170
1171 /* Second, activate normal shutdown */
117dcc57
ZJS		 1172 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1173 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1174 return r;
a40eb732
LP		 1175}
1176
4dfc092a
LP		 1177static void service_fix_output(Service *s) {
1178 assert(s);
1179
1180 /* If nothing has been explicitly configured, patch default
1181 * output in. If input is socket/tty we avoid this however,
1182 * since in that case we want output to default to the same
1183 * place as we read input from. */
1184
1185 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1186 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1187 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1188 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
4dfc092a
LP		 1189
1190 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1191 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1192 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
4dfc092a
LP		 1193}
1194
e537352b
LP		 1195static int service_load(Unit *u) {
1196 int r;
1197 Service *s = SERVICE(u);
1198
1199 assert(s);
1e2e8133 1200
5cb5a6ff 1201 /* Load a .service file */
e537352b 1202 if ((r = unit_load_fragment(u)) < 0)
5cb5a6ff
LP		 1203 return r;
1204
07459bb6 1205#ifdef HAVE_SYSV_COMPAT
bd77d0fc 1206 /* Load a classic init script as a fallback, if we couldn't find anything */
ac155bb8 1207 if (u->load_state == UNIT_STUB)
e537352b 1208 if ((r = service_load_sysv(s)) < 0)
23a177ef 1209 return r;
07459bb6 1210#endif
d46de8a1 1211
23a177ef 1212 /* Still nothing found? Then let's give up */
ac155bb8 1213 if (u->load_state == UNIT_STUB)
23a177ef 1214 return -ENOENT;
034c6ed7 1215
23a177ef
LP		 1216 /* We were able to load something, then let's add in the
1217 * dropin directories. */
1218 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
8e274523 1219 return r;
23a177ef
LP		 1220
1221 /* This is a new unit? Then let's add in some extras */
ac155bb8 1222 if (u->load_state == UNIT_LOADED) {
0b86feac
LP		 1223 if (s->type == _SERVICE_TYPE_INVALID)
1224 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1225
d568a335
MS		 1226 /* Oneshot services have disabled start timeout by default */
1227 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1228 s->timeout_start_usec = 0;
98709151 1229
4e2b0f9b
LP		 1230 service_fix_output(s);
1231
117dcc57
ZJS		 1232 r = unit_add_exec_dependencies(u, &s->exec_context);
1233 if (r < 0)
23a177ef
LP		 1234 return r;
1235
117dcc57
ZJS		 1236 r = unit_add_default_cgroups(u);
1237 if (r < 0)
23a177ef
LP		 1238 return r;
1239
07459bb6 1240#ifdef HAVE_SYSV_COMPAT
117dcc57
ZJS		 1241 r = sysv_fix_order(s);
1242 if (r < 0)
23a177ef 1243 return r;
07459bb6 1244#endif
05e343b7 1245
117dcc57
ZJS		 1246 r = fsck_fix_order(s);
1247 if (r < 0)
9fff8a1f
LP		 1248 return r;
1249
ee0dd802 1250 if (s->bus_name)
05e343b7 1251 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
a40eb732 1252 return r;
c952c6ec
LP		 1253
1254 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1255 s->notify_access = NOTIFY_MAIN;
a40eb732 1256
02c4ef9c
LP		 1257 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1258 s->notify_access = NOTIFY_MAIN;
1259
117dcc57
ZJS		 1260 if (s->type == SERVICE_DBUS || s->bus_name) {
1261 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES,
1262 SPECIAL_DBUS_SOCKET, NULL, true);
1263 if (r < 0)
a40eb732 1264 return r;
117dcc57 1265 }
a40eb732 1266
117dcc57
ZJS		 1267 if (UNIT(s)->default_dependencies) {
1268 r = service_add_default_dependencies(s);
1269 if (r < 0)
a40eb732 1270 return r;
117dcc57 1271 }
e06c73cc 1272
cba6e062 1273 r = unit_exec_context_defaults(u, &s->exec_context);
e06c73cc
LP		 1274 if (r < 0)
1275 return r;
8e274523
LP		 1276 }
1277
243b1432 1278 return service_verify(s);
034c6ed7
LP		 1279}
1280
87f0e418 1281static void service_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 1282
5cb5a6ff 1283 ServiceExecCommand c;
87f0e418 1284 Service *s = SERVICE(u);
47be870b 1285 const char *prefix2;
117dcc57 1286 char _cleanup_free_ *p2 = NULL;
5cb5a6ff
LP		 1287
1288 assert(s);
1289
47be870b
LP		 1290 p2 = strappend(prefix, "\t");
1291 prefix2 = p2 ? p2 : prefix;
44d8db9e 1292
5cb5a6ff 1293 fprintf(f,
81a2b7ce 1294 "%sService State: %s\n"
f42806df
LP		 1295 "%sResult: %s\n"
1296 "%sReload Result: %s\n"
81a2b7ce 1297 "%sPermissionsStartOnly: %s\n"
8e274523 1298 "%sRootDirectoryStartOnly: %s\n"
02ee865a 1299 "%sRemainAfterExit: %s\n"
3185a36b 1300 "%sGuessMainPID: %s\n"
c952c6ec 1301 "%sType: %s\n"
2cf3143a 1302 "%sRestart: %s\n"
c952c6ec 1303 "%sNotifyAccess: %s\n",
81a2b7ce 1304 prefix, service_state_to_string(s->state),
f42806df
LP		 1305 prefix, service_result_to_string(s->result),
1306 prefix, service_result_to_string(s->reload_result),
81a2b7ce 1307 prefix, yes_no(s->permissions_start_only),
8e274523 1308 prefix, yes_no(s->root_directory_start_only),
02ee865a 1309 prefix, yes_no(s->remain_after_exit),
3185a36b 1310 prefix, yes_no(s->guess_main_pid),
c952c6ec 1311 prefix, service_type_to_string(s->type),
2cf3143a 1312 prefix, service_restart_to_string(s->restart),
c952c6ec 1313 prefix, notify_access_to_string(s->notify_access));
5cb5a6ff 1314
70123e68
LP		 1315 if (s->control_pid > 0)
1316 fprintf(f,
bb00e604
LP		 1317 "%sControl PID: %lu\n",
1318 prefix, (unsigned long) s->control_pid);
70123e68
LP		 1319
1320 if (s->main_pid > 0)
1321 fprintf(f,
6dfa5494
LP		 1322 "%sMain PID: %lu\n"
1323 "%sMain PID Known: %s\n"
1324 "%sMain PID Alien: %s\n",
1325 prefix, (unsigned long) s->main_pid,
1326 prefix, yes_no(s->main_pid_known),
1327 prefix, yes_no(s->main_pid_alien));
70123e68 1328
034c6ed7
LP		 1329 if (s->pid_file)
1330 fprintf(f,
1331 "%sPIDFile: %s\n",
1332 prefix, s->pid_file);
1333
05e343b7
LP		 1334 if (s->bus_name)
1335 fprintf(f,
1336 "%sBusName: %s\n"
1337 "%sBus Name Good: %s\n",
1338 prefix, s->bus_name,
1339 prefix, yes_no(s->bus_name_good));
1340
4819ff03 1341 kill_context_dump(&s->kill_context, f, prefix);
5cb5a6ff
LP		 1342 exec_context_dump(&s->exec_context, f, prefix);
1343
e537352b 1344 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
5cb5a6ff 1345
44d8db9e
LP		 1346 if (!s->exec_command[c])
1347 continue;
1348
40d50879 1349 fprintf(f, "%s-> %s:\n",
94f04347 1350 prefix, service_exec_command_to_string(c));
44d8db9e
LP		 1351
1352 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 1353 }
44d8db9e 1354
07459bb6 1355#ifdef HAVE_SYSV_COMPAT
1b64d026 1356 if (s->is_sysv)
2c4104f0 1357 fprintf(f,
9fff8a1f
LP		 1358 "%sSysV Init Script has LSB Header: %s\n"
1359 "%sSysVEnabled: %s\n",
9fff8a1f
LP		 1360 prefix, yes_no(s->sysv_has_lsb),
1361 prefix, yes_no(s->sysv_enabled));
2c4104f0
LP		 1362
1363 if (s->sysv_start_priority >= 0)
1364 fprintf(f,
9fff8a1f
LP		 1365 "%sSysVStartPriority: %i\n",
1366 prefix, s->sysv_start_priority);
2c4104f0 1367
8309400a
LP		 1368 if (s->sysv_runlevels)
1369 fprintf(f, "%sSysVRunLevels: %s\n",
1370 prefix, s->sysv_runlevels);
07459bb6 1371#endif
23a177ef 1372
9fff8a1f
LP		 1373 if (s->fsck_passno > 0)
1374 fprintf(f,
1375 "%sFsckPassNo: %i\n",
1376 prefix, s->fsck_passno);
1377
8c47c732
LP		 1378 if (s->status_text)
1379 fprintf(f, "%sStatus Text: %s\n",
1380 prefix, s->status_text);
5cb5a6ff
LP		 1381}
1382
c5419d42 1383static int service_load_pid_file(Service *s, bool may_warn) {
117dcc57 1384 char _cleanup_free_ *k = NULL;
034c6ed7 1385 int r;
5925dd3c 1386 pid_t pid;
034c6ed7
LP		 1387
1388 assert(s);
1389
034c6ed7 1390 if (!s->pid_file)
13230d5d 1391 return -ENOENT;
034c6ed7 1392
117dcc57
ZJS		 1393 r = read_one_line_file(s->pid_file, &k);
1394 if (r < 0) {
c5419d42 1395 if (may_warn)
66870f90
ZJS		 1396 log_info_unit(UNIT(s)->id,
1397 "PID file %s not readable (yet?) after %s.",
1398 s->pid_file, service_state_to_string(s->state));
034c6ed7 1399 return r;
5375410b 1400 }
034c6ed7 1401
5925dd3c 1402 r = parse_pid(k, &pid);
bc41f93e
ZJS		 1403 if (r < 0) {
1404 if (may_warn)
1405 log_info_unit(UNIT(s)->id,
1406 "Failed to read PID from file %s: %s",
1407 s->pid_file, strerror(-r));
5925dd3c 1408 return r;
bc41f93e 1409 }
406eaf93 1410
5925dd3c 1411 if (kill(pid, 0) < 0 && errno != EPERM) {
c5419d42 1412 if (may_warn)
66870f90
ZJS		 1413 log_info_unit(UNIT(s)->id,
1414 "PID %lu read from file %s does not exist.",
1415 (unsigned long) pid, s->pid_file);
b8c597d5
LP		 1416 return -ESRCH;
1417 }
1418
db01f8b3
MS		 1419 if (s->main_pid_known) {
1420 if (pid == s->main_pid)
1421 return 0;
1422
66870f90
ZJS		 1423 log_debug_unit(UNIT(s)->id,
1424 "Main PID changing: %lu -> %lu",
1425 (unsigned long) s->main_pid, (unsigned long) pid);
db01f8b3
MS		 1426 service_unwatch_main_pid(s);
1427 s->main_pid_known = false;
3a111838 1428 } else
66870f90
ZJS		 1429 log_debug_unit(UNIT(s)->id,
1430 "Main PID loaded: %lu", (unsigned long) pid);
db01f8b3 1431
117dcc57
ZJS		 1432 r = service_set_main_pid(s, pid);
1433 if (r < 0)
16f6025e
LP		 1434 return r;
1435
117dcc57 1436 r = unit_watch_pid(UNIT(s), pid);
bc41f93e 1437 if (r < 0) {
5925dd3c 1438 /* FIXME: we need to do something here */
bc41f93e
ZJS		 1439 log_warning_unit(UNIT(s)->id,
1440 "Failed to watch PID %lu from service %s",
1441 (unsigned long) pid, UNIT(s)->id);
5925dd3c 1442 return r;
bc41f93e 1443 }
034c6ed7
LP		 1444
1445 return 0;
1446}
1447
4fbf50b3
LP		 1448static int service_search_main_pid(Service *s) {
1449 pid_t pid;
1450 int r;
1451
1452 assert(s);
1453
3185a36b
LP		 1454 /* If we know it anyway, don't ever fallback to unreliable
1455 * heuristics */
4fbf50b3
LP		 1456 if (s->main_pid_known)
1457 return 0;
1458
3185a36b
LP		 1459 if (!s->guess_main_pid)
1460 return 0;
1461
4fbf50b3
LP		 1462 assert(s->main_pid <= 0);
1463
117dcc57
ZJS		 1464 pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings);
1465 if (pid <= 0)
4fbf50b3
LP		 1466 return -ENOENT;
1467
66870f90
ZJS		 1468 log_debug_unit(UNIT(s)->id,
1469 "Main PID guessed: %lu", (unsigned long) pid);
117dcc57
ZJS		 1470 r = service_set_main_pid(s, pid);
1471 if (r < 0)
4fbf50b3
LP		 1472 return r;
1473
117dcc57
ZJS		 1474 r = unit_watch_pid(UNIT(s), pid);
1475 if (r < 0)
4fbf50b3
LP		 1476 /* FIXME: we need to do something here */
1477 return r;
1478
1479 return 0;
1480}
1481
6bda96a0 1482static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
ceee3d82 1483 Iterator i;
57020a3a 1484 Unit *u;
3e33402a
LP		 1485
1486 assert(s);
1487
f976f3f6
LP		 1488 /* Notifies all our sockets when we die */
1489
6cf6bbc2 1490 if (s->socket_fd >= 0)
57020a3a 1491 return;
3e33402a 1492
1124fe6f 1493 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
ac155bb8 1494 if (u->type == UNIT_SOCKET)
6bda96a0 1495 socket_notify_service_dead(SOCKET(u), failed_permanent);
3e33402a 1496
57020a3a 1497 return;
ceee3d82
LP		 1498}
1499
034c6ed7
LP		 1500static void service_set_state(Service *s, ServiceState state) {
1501 ServiceState old_state;
e056b01d 1502 const UnitActiveState *table;
5cb5a6ff
LP		 1503 assert(s);
1504
e056b01d
LP		 1505 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1506
034c6ed7 1507 old_state = s->state;
5cb5a6ff 1508 s->state = state;
034c6ed7 1509
3a111838
MS		 1510 service_unwatch_pid_file(s);
1511
034c6ed7
LP		 1512 if (state != SERVICE_START_PRE &&
1513 state != SERVICE_START &&
1514 state != SERVICE_START_POST &&
1515 state != SERVICE_RELOAD &&
1516 state != SERVICE_STOP &&
1517 state != SERVICE_STOP_SIGTERM &&
1518 state != SERVICE_STOP_SIGKILL &&
1519 state != SERVICE_STOP_POST &&
1520 state != SERVICE_FINAL_SIGTERM &&
1521 state != SERVICE_FINAL_SIGKILL &&
1522 state != SERVICE_AUTO_RESTART)
acbb0225 1523 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1524
7d55e835
LP		 1525 if (state != SERVICE_START &&
1526 state != SERVICE_START_POST &&
034c6ed7
LP		 1527 state != SERVICE_RUNNING &&
1528 state != SERVICE_RELOAD &&
1529 state != SERVICE_STOP &&
1530 state != SERVICE_STOP_SIGTERM &&
867b3b7d 1531 state != SERVICE_STOP_SIGKILL) {
5e94833f 1532 service_unwatch_main_pid(s);
867b3b7d
LP		 1533 s->main_command = NULL;
1534 }
034c6ed7
LP		 1535
1536 if (state != SERVICE_START_PRE &&
1537 state != SERVICE_START &&
1538 state != SERVICE_START_POST &&
1539 state != SERVICE_RELOAD &&
1540 state != SERVICE_STOP &&
1541 state != SERVICE_STOP_SIGTERM &&
1542 state != SERVICE_STOP_SIGKILL &&
1543 state != SERVICE_STOP_POST &&
1544 state != SERVICE_FINAL_SIGTERM &&
e537352b 1545 state != SERVICE_FINAL_SIGKILL) {
5e94833f 1546 service_unwatch_control_pid(s);
034c6ed7 1547 s->control_command = NULL;
a16e1123 1548 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
e537352b 1549 }
034c6ed7 1550
464876c9
LP		 1551 if (state == SERVICE_FAILED)
1552 service_notify_sockets_dead(s, s->result == SERVICE_FAILURE_START_LIMIT);
1553
ceee3d82
LP		 1554 if (state == SERVICE_DEAD ||
1555 state == SERVICE_STOP ||
1556 state == SERVICE_STOP_SIGTERM ||
1557 state == SERVICE_STOP_SIGKILL ||
1558 state == SERVICE_STOP_POST ||
1559 state == SERVICE_FINAL_SIGTERM ||
1560 state == SERVICE_FINAL_SIGKILL ||
ceee3d82 1561 state == SERVICE_AUTO_RESTART)
c2f34808 1562 service_notify_sockets_dead(s, false);
ceee3d82 1563
4f2d528d
LP		 1564 if (state != SERVICE_START_PRE &&
1565 state != SERVICE_START &&
6cf6bbc2
LP		 1566 state != SERVICE_START_POST &&
1567 state != SERVICE_RUNNING &&
1568 state != SERVICE_RELOAD &&
1569 state != SERVICE_STOP &&
1570 state != SERVICE_STOP_SIGTERM &&
1571 state != SERVICE_STOP_SIGKILL &&
1572 state != SERVICE_STOP_POST &&
1573 state != SERVICE_FINAL_SIGTERM &&
1574 state != SERVICE_FINAL_SIGKILL &&
1124fe6f 1575 !(state == SERVICE_DEAD && UNIT(s)->job)) {
4f2d528d 1576 service_close_socket_fd(s);
6cf6bbc2
LP		 1577 service_connection_unref(s);
1578 }
4f2d528d 1579
6d594baa 1580 if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
a6927d7f
MO		 1581 service_stop_watchdog(s);
1582
f6023656
LP		 1583 /* For the inactive states unit_notify() will trim the cgroup,
1584 * but for exit we have to do that ourselves... */
1124fe6f
MS		 1585 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1586 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
f6023656 1587
e537352b 1588 if (old_state != state)
66870f90
ZJS		 1589 log_debug_unit(UNIT(s)->id,
1590 "%s changed %s -> %s", UNIT(s)->id,
1591 service_state_to_string(old_state),
1592 service_state_to_string(state));
acbb0225 1593
e056b01d 1594 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
f42806df 1595 s->reload_result = SERVICE_SUCCESS;
034c6ed7
LP		 1596}
1597
a16e1123
LP		 1598static int service_coldplug(Unit *u) {
1599 Service *s = SERVICE(u);
1600 int r;
1601
1602 assert(s);
1603 assert(s->state == SERVICE_DEAD);
1604
1605 if (s->deserialized_state != s->state) {
1606
1607 if (s->deserialized_state == SERVICE_START_PRE ||
1608 s->deserialized_state == SERVICE_START ||
1609 s->deserialized_state == SERVICE_START_POST ||
1610 s->deserialized_state == SERVICE_RELOAD ||
1611 s->deserialized_state == SERVICE_STOP ||
1612 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1613 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1614 s->deserialized_state == SERVICE_STOP_POST ||
1615 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1616 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
e558336f 1617 s->deserialized_state == SERVICE_AUTO_RESTART) {
d568a335 1618 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
e558336f
LP		 1619 usec_t k;
1620
d568a335 1621 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
e558336f 1622
36697dc0
LP		 1623 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1624 if (r < 0)
e558336f
LP		 1625 return r;
1626 }
1627 }
a16e1123
LP		 1628
1629 if ((s->deserialized_state == SERVICE_START &&
1630 (s->type == SERVICE_FORKING ||
8c47c732 1631 s->type == SERVICE_DBUS ||
34e9ba66 1632 s->type == SERVICE_ONESHOT ||
8c47c732 1633 s->type == SERVICE_NOTIFY)) ||
a16e1123
LP		 1634 s->deserialized_state == SERVICE_START_POST ||
1635 s->deserialized_state == SERVICE_RUNNING ||
1636 s->deserialized_state == SERVICE_RELOAD ||
1637 s->deserialized_state == SERVICE_STOP ||
1638 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1639 s->deserialized_state == SERVICE_STOP_SIGKILL)
117dcc57
ZJS		 1640 if (s->main_pid > 0) {
1641 r = unit_watch_pid(UNIT(s), s->main_pid);
1642 if (r < 0)
a16e1123 1643 return r;
117dcc57 1644 }
a16e1123
LP		 1645
1646 if (s->deserialized_state == SERVICE_START_PRE ||
1647 s->deserialized_state == SERVICE_START ||
1648 s->deserialized_state == SERVICE_START_POST ||
1649 s->deserialized_state == SERVICE_RELOAD ||
1650 s->deserialized_state == SERVICE_STOP ||
1651 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1652 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1653 s->deserialized_state == SERVICE_STOP_POST ||
1654 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1655 s->deserialized_state == SERVICE_FINAL_SIGKILL)
117dcc57
ZJS		 1656 if (s->control_pid > 0) {
1657 r = unit_watch_pid(UNIT(s), s->control_pid);
1658 if (r < 0)
a16e1123 1659 return r;
117dcc57 1660 }
a16e1123 1661
bb242b7b
MO		 1662 if (s->deserialized_state == SERVICE_START_POST ||
1663 s->deserialized_state == SERVICE_RUNNING)
1664 service_handle_watchdog(s);
1665
a16e1123
LP		 1666 service_set_state(s, s->deserialized_state);
1667 }
a16e1123
LP		 1668 return 0;
1669}
1670
44d8db9e
LP		 1671static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1672 Iterator i;
1673 int r;
1674 int *rfds = NULL;
1675 unsigned rn_fds = 0;
57020a3a 1676 Unit *u;
44d8db9e
LP		 1677
1678 assert(s);
1679 assert(fds);
1680 assert(n_fds);
1681
6cf6bbc2
LP		 1682 if (s->socket_fd >= 0)
1683 return 0;
1684
1124fe6f 1685 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
44d8db9e
LP		 1686 int *cfds;
1687 unsigned cn_fds;
57020a3a
LP		 1688 Socket *sock;
1689
ac155bb8 1690 if (u->type != UNIT_SOCKET)
57020a3a
LP		 1691 continue;
1692
1693 sock = SOCKET(u);
44d8db9e 1694
117dcc57
ZJS		 1695 r = socket_collect_fds(sock, &cfds, &cn_fds);
1696 if (r < 0)
44d8db9e
LP		 1697 goto fail;
1698
1699 if (!cfds)
1700 continue;
1701
1702 if (!rfds) {
1703 rfds = cfds;
1704 rn_fds = cn_fds;
1705 } else {
1706 int *t;
1707
117dcc57
ZJS		 1708 t = new(int, rn_fds+cn_fds);
1709 if (!t) {
44d8db9e
LP		 1710 free(cfds);
1711 r = -ENOMEM;
1712 goto fail;
1713 }
1714
9c1b183c
LP		 1715 memcpy(t, rfds, rn_fds * sizeof(int));
1716 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
44d8db9e
LP		 1717 free(rfds);
1718 free(cfds);
1719
1720 rfds = t;
1721 rn_fds = rn_fds+cn_fds;
1722 }
1723 }
1724
1725 *fds = rfds;
1726 *n_fds = rn_fds;
3e33402a 1727
44d8db9e
LP		 1728 return 0;
1729
1730fail:
1731 free(rfds);
3e33402a 1732
44d8db9e
LP		 1733 return r;
1734}
1735
81a2b7ce
LP		 1736static int service_spawn(
1737 Service *s,
1738 ExecCommand *c,
1739 bool timeout,
1740 bool pass_fds,
1741 bool apply_permissions,
1742 bool apply_chroot,
1e3ad081 1743 bool apply_tty_stdin,
c952c6ec 1744 bool set_notify_socket,
ecedd90f 1745 bool is_control,
81a2b7ce
LP		 1746 pid_t *_pid) {
1747
034c6ed7
LP		 1748 pid_t pid;
1749 int r;
117dcc57
ZJS		 1750 int *fds = NULL;
1751 int _cleanup_free_ *fdsbuf = NULL;
2105e76a 1752 unsigned n_fds = 0, n_env = 0;
117dcc57
ZJS		 1753 char _cleanup_strv_free_
1754 **argv = NULL, **final_env = NULL, **our_env = NULL;
034c6ed7
LP		 1755
1756 assert(s);
1757 assert(c);
1758 assert(_pid);
1759
6cf6bbc2
LP		 1760 if (pass_fds ||
1761 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1762 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1763 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1764
4f2d528d
LP		 1765 if (s->socket_fd >= 0) {
1766 fds = &s->socket_fd;
1767 n_fds = 1;
6cf6bbc2 1768 } else {
117dcc57
ZJS		 1769 r = service_collect_fds(s, &fdsbuf, &n_fds);
1770 if (r < 0)
6cf6bbc2
LP		 1771 goto fail;
1772
1773 fds = fdsbuf;
1774 }
4f2d528d 1775 }
44d8db9e 1776
d568a335 1777 if (timeout && s->timeout_start_usec) {
117dcc57
ZJS		 1778 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1779 s->timeout_start_usec, &s->timer_watch);
d568a335 1780 if (r < 0)
034c6ed7
LP		 1781 goto fail;
1782 } else
acbb0225 1783 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1784
117dcc57
ZJS		 1785 argv = unit_full_printf_strv(UNIT(s), c->argv);
1786 if (!argv) {
9e2f7c11
LP		 1787 r = -ENOMEM;
1788 goto fail;
1789 }
1790
97ae63e2
LP		 1791 our_env = new0(char*, 5);
1792 if (!our_env) {
2105e76a
LP		 1793 r = -ENOMEM;
1794 goto fail;
1795 }
c952c6ec 1796
2105e76a 1797 if (set_notify_socket)
1124fe6f 1798 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
c952c6ec
LP		 1799 r = -ENOMEM;
1800 goto fail;
1801 }
1802
2105e76a
LP		 1803 if (s->main_pid > 0)
1804 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
c952c6ec
LP		 1805 r = -ENOMEM;
1806 goto fail;
1807 }
2105e76a 1808
6e0bcc98
MO		 1809 if (s->watchdog_usec > 0)
1810 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1811 r = -ENOMEM;
1812 goto fail;
1813 }
1814
97ae63e2
LP		 1815 if (s->meta.manager->running_as != SYSTEMD_SYSTEM)
1816 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1817 r = -ENOMEM;
1818 goto fail;
1819 }
1820
1821 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1822 if (!final_env) {
2105e76a
LP		 1823 r = -ENOMEM;
1824 goto fail;
1825 }
c952c6ec 1826
9e2f7c11
LP		 1827 r = exec_spawn(c,
1828 argv,
1829 &s->exec_context,
1830 fds, n_fds,
2105e76a 1831 final_env,
9e2f7c11
LP		 1832 apply_permissions,
1833 apply_chroot,
1e3ad081 1834 apply_tty_stdin,
1124fe6f
MS		 1835 UNIT(s)->manager->confirm_spawn,
1836 UNIT(s)->cgroup_bondings,
1837 UNIT(s)->cgroup_attributes,
ecedd90f 1838 is_control ? "control" : NULL,
62bca2c6 1839 UNIT(s)->id,
f2b68789 1840 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
9e2f7c11 1841 &pid);
9e2f7c11 1842 if (r < 0)
034c6ed7
LP		 1843 goto fail;
1844
117dcc57
ZJS		 1845 r = unit_watch_pid(UNIT(s), pid);
1846 if (r < 0)
034c6ed7
LP		 1847 /* FIXME: we need to do something here */
1848 goto fail;
1849
1850 *_pid = pid;
1851
5cb5a6ff 1852 return 0;
034c6ed7
LP		 1853
1854fail:
1855 if (timeout)
acbb0225 1856 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7
LP		 1857
1858 return r;
1859}
1860
80876c20
LP		 1861static int main_pid_good(Service *s) {
1862 assert(s);
1863
1864 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1865 * don't know */
1866
1867 /* If we know the pid file, then lets just check if it is
1868 * still valid */
6dfa5494
LP		 1869 if (s->main_pid_known) {
1870
1871 /* If it's an alien child let's check if it is still
1872 * alive ... */
1873 if (s->main_pid_alien)
1874 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1875
1876 /* .. otherwise assume we'll get a SIGCHLD for it,
1877 * which we really should wait for to collect exit
1878 * status and code */
80876c20 1879 return s->main_pid > 0;
6dfa5494 1880 }
80876c20
LP		 1881
1882 /* We don't know the pid */
1883 return -EAGAIN;
1884}
1885
1886static int control_pid_good(Service *s) {
1887 assert(s);
1888
1889 return s->control_pid > 0;
1890}
1891
1892static int cgroup_good(Service *s) {
1893 int r;
1894
1895 assert(s);
1896
117dcc57
ZJS		 1897 r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings);
1898 if (r < 0)
80876c20
LP		 1899 return r;
1900
1901 return !r;
1902}
1903
f42806df 1904static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
034c6ed7
LP		 1905 int r;
1906 assert(s);
1907
f42806df
LP		 1908 if (f != SERVICE_SUCCESS)
1909 s->result = f;
034c6ed7 1910
0c7f15b3
MS		 1911 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1912
034c6ed7 1913 if (allow_restart &&
47342320 1914 !s->forbid_restart &&
034c6ed7 1915 (s->restart == SERVICE_RESTART_ALWAYS ||
f42806df
LP		 1916 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1917 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1918 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
96342de6
LN		 1919 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1920 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1921 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1922 (s->result != SERVICE_FAILURE_SIGNAL ||
1923 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1924 ) {
034c6ed7 1925
36697dc0 1926 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
f42806df 1927 if (r < 0)
034c6ed7
LP		 1928 goto fail;
1929
1930 service_set_state(s, SERVICE_AUTO_RESTART);
0c7f15b3 1931 }
034c6ed7 1932
47342320
LP		 1933 s->forbid_restart = false;
1934
c17ec25e
MS		 1935 /* we want fresh tmpdirs in case service is started again immediately */
1936 exec_context_tmp_dirs_done(&s->exec_context);
1937
034c6ed7
LP		 1938 return;
1939
1940fail:
66870f90
ZJS		 1941 log_warning_unit(UNIT(s)->id,
1942 "%s failed to run install restart timer: %s",
1943 UNIT(s)->id, strerror(-r));
f42806df 1944 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1945}
1946
f42806df 1947static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
034c6ed7 1948
f42806df 1949static void service_enter_stop_post(Service *s, ServiceResult f) {
034c6ed7
LP		 1950 int r;
1951 assert(s);
1952
f42806df
LP		 1953 if (f != SERVICE_SUCCESS)
1954 s->result = f;
034c6ed7 1955
5e94833f
LP		 1956 service_unwatch_control_pid(s);
1957
117dcc57
ZJS		 1958 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1959 if (s->control_command) {
867b3b7d
LP		 1960 s->control_command_id = SERVICE_EXEC_STOP_POST;
1961
ecedd90f
LP		 1962 r = service_spawn(s,
1963 s->control_command,
1964 true,
1965 false,
1966 !s->permissions_start_only,
1967 !s->root_directory_start_only,
1968 true,
1969 false,
1970 true,
1971 &s->control_pid);
1972 if (r < 0)
034c6ed7
LP		 1973 goto fail;
1974
d6ea93e3 1975
80876c20
LP		 1976 service_set_state(s, SERVICE_STOP_POST);
1977 } else
f42806df 1978 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 1979
1980 return;
1981
1982fail:
66870f90
ZJS		 1983 log_warning_unit(UNIT(s)->id,
1984 "%s failed to run 'stop-post' task: %s",
1985 UNIT(s)->id, strerror(-r));
f42806df 1986 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1987}
1988
f42806df 1989static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
034c6ed7 1990 int r;
034c6ed7
LP		 1991
1992 assert(s);
1993
f42806df
LP		 1994 if (f != SERVICE_SUCCESS)
1995 s->result = f;
034c6ed7 1996
cd2086fe
LP		 1997 r = unit_kill_context(
1998 UNIT(s),
1999 &s->kill_context,
2000 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
2001 s->main_pid,
2002 s->control_pid,
2003 s->main_pid_alien);
2004 if (r < 0)
2005 goto fail;
034c6ed7 2006
cd2086fe 2007 if (r > 0) {
d568a335 2008 if (s->timeout_stop_usec > 0) {
117dcc57
ZJS		 2009 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2010 s->timeout_stop_usec, &s->timer_watch);
d568a335 2011 if (r < 0)
e558336f 2012 goto fail;
d568a335 2013 }
d6ea93e3 2014
80876c20
LP		 2015 service_set_state(s, state);
2016 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2017 service_enter_stop_post(s, SERVICE_SUCCESS);
80876c20 2018 else
f42806df 2019 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 2020
2021 return;
2022
2023fail:
66870f90
ZJS		 2024 log_warning_unit(UNIT(s)->id,
2025 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
034c6ed7 2026
80876c20 2027 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2028 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
034c6ed7 2029 else
f42806df 2030 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2031}
2032
f42806df 2033static void service_enter_stop(Service *s, ServiceResult f) {
034c6ed7 2034 int r;
5925dd3c 2035
034c6ed7
LP		 2036 assert(s);
2037
f42806df
LP		 2038 if (f != SERVICE_SUCCESS)
2039 s->result = f;
034c6ed7 2040
5e94833f
LP		 2041 service_unwatch_control_pid(s);
2042
117dcc57
ZJS		 2043 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2044 if (s->control_command) {
867b3b7d
LP		 2045 s->control_command_id = SERVICE_EXEC_STOP;
2046
ecedd90f
LP		 2047 r = service_spawn(s,
2048 s->control_command,
2049 true,
2050 false,
2051 !s->permissions_start_only,
2052 !s->root_directory_start_only,
2053 false,
2054 false,
2055 true,
2056 &s->control_pid);
2057 if (r < 0)
034c6ed7
LP		 2058 goto fail;
2059
80876c20
LP		 2060 service_set_state(s, SERVICE_STOP);
2061 } else
f42806df 2062 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 2063
2064 return;
2065
2066fail:
66870f90
ZJS		 2067 log_warning_unit(UNIT(s)->id,
2068 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2069 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2070}
2071
f42806df 2072static void service_enter_running(Service *s, ServiceResult f) {
4eab639f 2073 int main_pid_ok, cgroup_ok;
80876c20
LP		 2074 assert(s);
2075
f42806df
LP		 2076 if (f != SERVICE_SUCCESS)
2077 s->result = f;
80876c20 2078
4eab639f
LP		 2079 main_pid_ok = main_pid_good(s);
2080 cgroup_ok = cgroup_good(s);
2081
2082 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
05e343b7 2083 (s->bus_name_good || s->type != SERVICE_DBUS))
80876c20 2084 service_set_state(s, SERVICE_RUNNING);
02ee865a 2085 else if (s->remain_after_exit)
80876c20
LP		 2086 service_set_state(s, SERVICE_EXITED);
2087 else
f42806df 2088 service_enter_stop(s, SERVICE_SUCCESS);
80876c20
LP		 2089}
2090
034c6ed7
LP		 2091static void service_enter_start_post(Service *s) {
2092 int r;
2093 assert(s);
2094
5e94833f
LP		 2095 service_unwatch_control_pid(s);
2096
bb242b7b
MO		 2097 if (s->watchdog_usec > 0)
2098 service_reset_watchdog(s);
2099
117dcc57
ZJS		 2100 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2101 if (s->control_command) {
867b3b7d
LP		 2102 s->control_command_id = SERVICE_EXEC_START_POST;
2103
ecedd90f
LP		 2104 r = service_spawn(s,
2105 s->control_command,
2106 true,
2107 false,
2108 !s->permissions_start_only,
2109 !s->root_directory_start_only,
2110 false,
2111 false,
2112 true,
2113 &s->control_pid);
2114 if (r < 0)
034c6ed7
LP		 2115 goto fail;
2116
80876c20
LP		 2117 service_set_state(s, SERVICE_START_POST);
2118 } else
f42806df 2119 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2120
2121 return;
2122
2123fail:
66870f90
ZJS		 2124 log_warning_unit(UNIT(s)->id,
2125 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2126 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2127}
2128
2129static void service_enter_start(Service *s) {
2130 pid_t pid;
2131 int r;
867b3b7d 2132 ExecCommand *c;
034c6ed7
LP		 2133
2134 assert(s);
2135
2136 assert(s->exec_command[SERVICE_EXEC_START]);
34e9ba66 2137 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
034c6ed7 2138
80876c20
LP		 2139 if (s->type == SERVICE_FORKING)
2140 service_unwatch_control_pid(s);
2141 else
2142 service_unwatch_main_pid(s);
2143
8f53a7b8
LP		 2144 /* We want to ensure that nobody leaks processes from
2145 * START_PRE here, so let's go on a killing spree, People
2146 * should not spawn long running processes from START_PRE. */
88f3e0c9 2147 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
8f53a7b8 2148
867b3b7d
LP		 2149 if (s->type == SERVICE_FORKING) {
2150 s->control_command_id = SERVICE_EXEC_START;
2151 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2152
2153 s->main_command = NULL;
2154 } else {
2155 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2156 s->control_command = NULL;
2157
2158 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2159 }
34e9ba66 2160
ecedd90f
LP		 2161 r = service_spawn(s,
2162 c,
117dcc57
ZJS		 2163 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2164 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
ecedd90f
LP		 2165 true,
2166 true,
2167 true,
2168 true,
2169 s->notify_access != NOTIFY_NONE,
2170 false,
2171 &pid);
2172 if (r < 0)
034c6ed7
LP		 2173 goto fail;
2174
f2b68789 2175 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
034c6ed7
LP		 2176 /* For simple services we immediately start
2177 * the START_POST binaries. */
2178
5925dd3c 2179 service_set_main_pid(s, pid);
034c6ed7
LP		 2180 service_enter_start_post(s);
2181
2182 } else if (s->type == SERVICE_FORKING) {
2183
2184 /* For forking services we wait until the start
2185 * process exited. */
2186
e55224ca 2187 s->control_pid = pid;
80876c20
LP		 2188 service_set_state(s, SERVICE_START);
2189
34e9ba66 2190 } else if (s->type == SERVICE_ONESHOT ||
8c47c732
LP		 2191 s->type == SERVICE_DBUS ||
2192 s->type == SERVICE_NOTIFY) {
7d55e835 2193
34e9ba66 2194 /* For oneshot services we wait until the start
7d55e835
LP		 2195 * process exited, too, but it is our main process. */
2196
05e343b7 2197 /* For D-Bus services we know the main pid right away,
8c47c732
LP		 2198 * but wait for the bus name to appear on the
2199 * bus. Notify services are similar. */
05e343b7 2200
5925dd3c 2201 service_set_main_pid(s, pid);
80876c20 2202 service_set_state(s, SERVICE_START);
034c6ed7
LP		 2203 } else
2204 assert_not_reached("Unknown service type");
2205
2206 return;
2207
2208fail:
66870f90
ZJS		 2209 log_warning_unit(UNIT(s)->id,
2210 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2211 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2212}
2213
2214static void service_enter_start_pre(Service *s) {
2215 int r;
2216
2217 assert(s);
2218
5e94833f
LP		 2219 service_unwatch_control_pid(s);
2220
117dcc57
ZJS		 2221 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2222 if (s->control_command) {
8f53a7b8
LP		 2223
2224 /* Before we start anything, let's clear up what might
2225 * be left from previous runs. */
117dcc57
ZJS		 2226 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL,
2227 true,true, NULL, "control");
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
87f0e418
LP		 2578static bool service_can_reload(Unit *u) {
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
87f0e418 2790static 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
701cc384
LP		 2826static bool service_check_snapshot(Unit *u) {
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) {
034c6ed7 3051
34e9ba66
LP		 3052 s->control_pid = 0;
3053
b708e7ce 3054 if (s->control_command) {
117dcc57
ZJS		 3055 exec_status_exit(&s->control_command->exec_status,
3056 &s->exec_context, pid, code, status);
a16e1123 3057
b708e7ce 3058 if (s->control_command->ignore)
f42806df 3059 f = SERVICE_SUCCESS;
b708e7ce
LP		 3060 }
3061
66870f90
ZJS		 3062 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3063 "%s: control process exited, code=%s status=%i",
3064 u->id, sigchld_code_to_string(code), status);
f42806df
LP		 3065
3066 if (f != SERVICE_SUCCESS)
3067 s->result = f;
034c6ed7 3068
88f3e0c9
LP		 3069 /* Immediately get rid of the cgroup, so that the
3070 * kernel doesn't delay the cgroup empty messages for
3071 * the service cgroup any longer than necessary */
117dcc57
ZJS		 3072 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL,
3073 true, true, NULL, "control");
88f3e0c9 3074
34e9ba66
LP		 3075 if (s->control_command &&
3076 s->control_command->command_next &&
f42806df 3077 f == SERVICE_SUCCESS) {
034c6ed7
LP		 3078
3079 /* There is another command to *
3080 * execute, so let's do that. */
3081
66870f90
ZJS		 3082 log_debug_unit(u->id,
3083 "%s running next control command for state %s",
3084 u->id, service_state_to_string(s->state));
f42806df 3085 service_run_next_control(s);
034c6ed7 3086
80876c20 3087 } else {
034c6ed7
LP		 3088 /* No further commands for this step, so let's
3089 * figure out what to do next */
3090
a16e1123
LP		 3091 s->control_command = NULL;
3092 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3093
66870f90
ZJS		 3094 log_debug_unit(u->id,
3095 "%s got final SIGCHLD for state %s",
3096 u->id, service_state_to_string(s->state));
bd982a8b 3097
034c6ed7
LP		 3098 switch (s->state) {
3099
3100 case SERVICE_START_PRE:
f42806df 3101 if (f == SERVICE_SUCCESS)
034c6ed7
LP		 3102 service_enter_start(s);
3103 else
f42806df 3104 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
034c6ed7
LP		 3105 break;
3106
3107 case SERVICE_START:
bfba3256
LP		 3108 if (s->type != SERVICE_FORKING)
3109 /* Maybe spurious event due to a reload that changed the type? */
3110 break;
034c6ed7 3111
f42806df
LP		 3112 if (f != SERVICE_SUCCESS) {
3113 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3a111838
MS		 3114 break;
3115 }
034c6ed7 3116
3a111838 3117 if (s->pid_file) {
f42806df
LP		 3118 bool has_start_post;
3119 int r;
3120
3a111838
MS		 3121 /* Let's try to load the pid file here if we can.
3122 * The PID file might actually be created by a START_POST
3123 * script. In that case don't worry if the loading fails. */
f42806df
LP		 3124
3125 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3126 r = service_load_pid_file(s, !has_start_post);
3a111838
MS		 3127 if (!has_start_post && r < 0) {
3128 r = service_demand_pid_file(s);
3129 if (r < 0 || !cgroup_good(s))
f42806df 3130 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3131 break;
3132 }
034c6ed7 3133 } else
3a111838 3134 service_search_main_pid(s);
034c6ed7 3135
3a111838 3136 service_enter_start_post(s);
034c6ed7
LP		 3137 break;
3138
3139 case SERVICE_START_POST:
f42806df
LP		 3140 if (f != SERVICE_SUCCESS) {
3141 service_enter_stop(s, f);
2096e009 3142 break;
034c6ed7
LP		 3143 }
3144
2096e009 3145 if (s->pid_file) {
f42806df
LP		 3146 int r;
3147
3148 r = service_load_pid_file(s, true);
2096e009
MS		 3149 if (r < 0) {
3150 r = service_demand_pid_file(s);
3151 if (r < 0 || !cgroup_good(s))
f42806df 3152 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2096e009
MS		 3153 break;
3154 }
3155 } else
3156 service_search_main_pid(s);
3157
f42806df 3158 service_enter_running(s, SERVICE_SUCCESS);
3185a36b 3159 break;
034c6ed7
LP		 3160
3161 case SERVICE_RELOAD:
f42806df 3162 if (f == SERVICE_SUCCESS) {
5375410b 3163 service_load_pid_file(s, true);
3185a36b
LP		 3164 service_search_main_pid(s);
3165 }
3166
f42806df
LP		 3167 s->reload_result = f;
3168 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 3169 break;
3170
3171 case SERVICE_STOP:
f42806df 3172 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
034c6ed7
LP		 3173 break;
3174
3175 case SERVICE_STOP_SIGTERM:
3176 case SERVICE_STOP_SIGKILL:
3177 if (main_pid_good(s) <= 0)
f42806df 3178 service_enter_stop_post(s, f);
034c6ed7
LP		 3179
3180 /* If there is still a service
3181 * process around, wait until
3182 * that one quit, too */
3183 break;
3184
3185 case SERVICE_STOP_POST:
3186 case SERVICE_FINAL_SIGTERM:
3187 case SERVICE_FINAL_SIGKILL:
f42806df 3188 service_enter_dead(s, f, true);
034c6ed7
LP		 3189 break;
3190
3191 default:
3192 assert_not_reached("Uh, control process died at wrong time.");
3193 }
3194 }
8c47c732 3195 }
c4e2ceae
LP		 3196
3197 /* Notify clients about changed exit status */
3198 unit_add_to_dbus_queue(u);
034c6ed7
LP		 3199}
3200
acbb0225 3201static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
87f0e418 3202 Service *s = SERVICE(u);
034c6ed7
LP		 3203
3204 assert(s);
3205 assert(elapsed == 1);
3206
bb242b7b
MO		 3207 if (w == &s->watchdog_watch) {
3208 service_handle_watchdog(s);
3209 return;
3210 }
3211
acbb0225 3212 assert(w == &s->timer_watch);
034c6ed7
LP		 3213
3214 switch (s->state) {
3215
3216 case SERVICE_START_PRE:
3217 case SERVICE_START:
66870f90
ZJS		 3218 log_warning_unit(u->id,
3219 "%s operation timed out. Terminating.", u->id);
f42806df 3220 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
80876c20
LP		 3221 break;
3222
034c6ed7 3223 case SERVICE_START_POST:
66870f90
ZJS		 3224 log_warning_unit(u->id,
3225 "%s operation timed out. Stopping.", u->id);
f42806df 3226 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3227 break;
3228
e2f3b44c 3229 case SERVICE_RELOAD:
66870f90
ZJS		 3230 log_warning_unit(u->id,
3231 "%s operation timed out. Stopping.", u->id);
f42806df
LP		 3232 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3233 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c
LP		 3234 break;
3235
034c6ed7 3236 case SERVICE_STOP:
66870f90
ZJS		 3237 log_warning_unit(u->id,
3238 "%s stopping timed out. Terminating.", u->id);
f42806df 3239 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3240 break;
3241
3242 case SERVICE_STOP_SIGTERM:
4819ff03 3243 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3244 log_warning_unit(u->id,
3245 "%s stopping timed out. Killing.", u->id);
f42806df 3246 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3247 } else {
66870f90
ZJS		 3248 log_warning_unit(u->id,
3249 "%s stopping timed out. Skipping SIGKILL.", u->id);
f42806df 3250 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
ba035df2
LP		 3251 }
3252
034c6ed7
LP		 3253 break;
3254
3255 case SERVICE_STOP_SIGKILL:
35b8ca3a 3256 /* Uh, we sent a SIGKILL and it is still not gone?
034c6ed7
LP		 3257 * Must be something we cannot kill, so let's just be
3258 * weirded out and continue */
3259
66870f90
ZJS		 3260 log_warning_unit(u->id,
3261 "%s still around after SIGKILL. Ignoring.", u->id);
f42806df 3262 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3263 break;
3264
3265 case SERVICE_STOP_POST:
66870f90
ZJS		 3266 log_warning_unit(u->id,
3267 "%s stopping timed out (2). Terminating.", u->id);
f42806df 3268 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3269 break;
3270
3271 case SERVICE_FINAL_SIGTERM:
4819ff03 3272 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3273 log_warning_unit(u->id,
3274 "%s stopping timed out (2). Killing.", u->id);
f42806df 3275 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3276 } else {
66870f90
ZJS		 3277 log_warning_unit(u->id,
3278 "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3279 u->id);
f42806df 3280 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
ba035df2
LP		 3281 }
3282
034c6ed7
LP		 3283 break;
3284
3285 case SERVICE_FINAL_SIGKILL:
66870f90
ZJS		 3286 log_warning_unit(u->id,
3287 "%s still around after SIGKILL (2). Entering failed mode.", u->id);
f42806df 3288 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
034c6ed7
LP		 3289 break;
3290
3291 case SERVICE_AUTO_RESTART:
66870f90
ZJS		 3292 log_info_unit(u->id,
3293 "%s holdoff time over, scheduling restart.", u->id);
034c6ed7
LP		 3294 service_enter_restart(s);
3295 break;
3296
3297 default:
3298 assert_not_reached("Timeout at wrong time.");
3299 }
5cb5a6ff
LP		 3300}
3301
8e274523
LP		 3302static void service_cgroup_notify_event(Unit *u) {
3303 Service *s = SERVICE(u);
3304
3305 assert(u);
3306
66870f90
ZJS		 3307 log_debug_unit(u->id,
3308 "%s: cgroup is empty", u->id);
8e274523
LP		 3309
3310 switch (s->state) {
3311
3312 /* Waiting for SIGCHLD is usually more interesting,
3313 * because it includes return codes/signals. Which is
3314 * why we ignore the cgroup events for most cases,
3315 * except when we don't know pid which to expect the
3316 * SIGCHLD for. */
3317
3a111838
MS		 3318 case SERVICE_START:
3319 case SERVICE_START_POST:
3320 /* If we were hoping for the daemon to write its PID file,
3321 * we can give up now. */
3322 if (s->pid_file_pathspec) {
66870f90
ZJS		 3323 log_warning_unit(u->id,
3324 "%s never wrote its PID file. Failing.", UNIT(s)->id);
3a111838
MS		 3325 service_unwatch_pid_file(s);
3326 if (s->state == SERVICE_START)
f42806df 3327 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838 3328 else
f42806df 3329 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3330 }
3331 break;
3332
8e274523 3333 case SERVICE_RUNNING:
f42806df
LP		 3334 /* service_enter_running() will figure out what to do */
3335 service_enter_running(s, SERVICE_SUCCESS);
8e274523
LP		 3336 break;
3337
28708d8a
LP		 3338 case SERVICE_STOP_SIGTERM:
3339 case SERVICE_STOP_SIGKILL:
6dfa5494 3340
28708d8a 3341 if (main_pid_good(s) <= 0 && !control_pid_good(s))
f42806df 3342 service_enter_stop_post(s, SERVICE_SUCCESS);
28708d8a
LP		 3343
3344 break;
3345
7f97f0fe
LP		 3346 case SERVICE_FINAL_SIGTERM:
3347 case SERVICE_FINAL_SIGKILL:
3348 if (main_pid_good(s) <= 0 && !control_pid_good(s))
e201a038 3349 service_enter_dead(s, SERVICE_SUCCESS, true);
7f97f0fe
LP		 3350
3351 break;
3352
8e274523
LP		 3353 default:
3354 ;
3355 }
3356}
3357
c952c6ec 3358static void service_notify_message(Unit *u, pid_t pid, char **tags) {
8c47c732
LP		 3359 Service *s = SERVICE(u);
3360 const char *e;
3361
3362 assert(u);
3363
c952c6ec 3364 if (s->notify_access == NOTIFY_NONE) {
66870f90
ZJS		 3365 log_warning_unit(u->id,
3366 "%s: Got notification message from PID %lu, but reception is disabled.",
3367 u->id, (unsigned long) pid);
c952c6ec
LP		 3368 return;
3369 }
3370
3371 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
66870f90
ZJS		 3372 log_warning_unit(u->id,
3373 "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3374 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
c952c6ec
LP		 3375 return;
3376 }
3377
66870f90
ZJS		 3378 log_debug_unit(u->id,
3379 "%s: Got message", u->id);
8c47c732
LP		 3380
3381 /* Interpret MAINPID= */
3382 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3383 (s->state == SERVICE_START ||
3384 s->state == SERVICE_START_POST ||
3385 s->state == SERVICE_RUNNING ||
3386 s->state == SERVICE_RELOAD)) {
8c47c732 3387
5925dd3c 3388 if (parse_pid(e + 8, &pid) < 0)
66870f90
ZJS		 3389 log_warning_unit(u->id,
3390 "Failed to parse notification message %s", e);
8c47c732 3391 else {
66870f90
ZJS		 3392 log_debug_unit(u->id,
3393 "%s: got %s", u->id, e);
5925dd3c 3394 service_set_main_pid(s, pid);
8c47c732
LP		 3395 }
3396 }
3397
3398 /* Interpret READY= */
3399 if (s->type == SERVICE_NOTIFY &&
3400 s->state == SERVICE_START &&
3401 strv_find(tags, "READY=1")) {
66870f90
ZJS		 3402 log_debug_unit(u->id,
3403 "%s: got READY=1", u->id);
8c47c732
LP		 3404
3405 service_enter_start_post(s);
3406 }
3407
3408 /* Interpret STATUS= */
7f110ff9
LP		 3409 e = strv_find_prefix(tags, "STATUS=");
3410 if (e) {
8c47c732
LP		 3411 char *t;
3412
3a2776bc 3413 if (e[7]) {
7f110ff9
LP		 3414
3415 if (!utf8_is_valid(e+7)) {
66870f90
ZJS		 3416 log_warning_unit(u->id,
3417 "Status message in notification is not UTF-8 clean.");
7f110ff9
LP		 3418 return;
3419 }
3420
3421 t = strdup(e+7);
3422 if (!t) {
66870f90
ZJS		 3423 log_error_unit(u->id,
3424 "Failed to allocate string.");
3a2776bc
LP		 3425 return;
3426 }
3427
66870f90
ZJS		 3428 log_debug_unit(u->id,
3429 "%s: got %s", u->id, e);
8c47c732 3430
3a2776bc
LP		 3431 free(s->status_text);
3432 s->status_text = t;
3433 } else {
3434 free(s->status_text);
3435 s->status_text = NULL;
3436 }
8c47c732 3437
8c47c732 3438 }
a6927d7f 3439 if (strv_find(tags, "WATCHDOG=1")) {
66870f90
ZJS		 3440 log_debug_unit(u->id,
3441 "%s: got WATCHDOG=1", u->id);
90527fbb
MO		 3442 if (dual_timestamp_is_set(&s->watchdog_timestamp))
3443 service_reset_watchdog(s);
a6927d7f 3444 }
c4e2ceae
LP		 3445
3446 /* Notify clients about changed status or main pid */
3447 unit_add_to_dbus_queue(u);
8c47c732
LP		 3448}
3449
07459bb6 3450#ifdef HAVE_SYSV_COMPAT
de3910a3 3451
2c4104f0 3452static int service_enumerate(Manager *m) {
2c4104f0
LP		 3453 char **p;
3454 unsigned i;
117dcc57
ZJS		 3455 DIR _cleanup_closedir_ *d = NULL;
3456 char _cleanup_free_ *path = NULL, *fpath = NULL, *name = NULL;
3457 Set *runlevel_services[ELEMENTSOF(rcnd_table)];
3458 Set _cleanup_set_free_ *shutdown_services = NULL;
c68364b7
LP		 3459 Unit *service;
3460 Iterator j;
2c4104f0
LP		 3461 int r;
3462
3463 assert(m);
3464
67445f4e 3465 if (m->running_as != SYSTEMD_SYSTEM)
b1bc08e5
LP		 3466 return 0;
3467
c68364b7
LP		 3468 zero(runlevel_services);
3469
84e3543e 3470 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
09cd1ab1 3471 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
2c4104f0
LP		 3472 struct dirent *de;
3473
3474 free(path);
b7def684 3475 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
70132bd0 3476 if (!path) {
2c4104f0
LP		 3477 r = -ENOMEM;
3478 goto finish;
3479 }
3480
3481 if (d)
3482 closedir(d);
3483
117dcc57
ZJS		 3484 d = opendir(path);
3485 if (!d) {
2c4104f0 3486 if (errno != ENOENT)
117dcc57 3487 log_warning("opendir(%s) failed: %s", path, strerror(errno));
2c4104f0
LP		 3488
3489 continue;
3490 }
3491
3492 while ((de = readdir(d))) {
db06e3b6 3493 int a, b;
2c4104f0
LP		 3494
3495 if (ignore_file(de->d_name))
3496 continue;
3497
3498 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3499 continue;
3500
3501 if (strlen(de->d_name) < 4)
3502 continue;
3503
db06e3b6
LP		 3504 a = undecchar(de->d_name[1]);
3505 b = undecchar(de->d_name[2]);
3506
3507 if (a < 0 || b < 0)
3508 continue;
3509
2c4104f0 3510 free(fpath);
b7def684 3511 fpath = strjoin(path, "/", de->d_name, NULL);
8ea913b2 3512 if (!fpath) {
2c4104f0
LP		 3513 r = -ENOMEM;
3514 goto finish;
3515 }
3516
3517 if (access(fpath, X_OK) < 0) {
3518
3519 if (errno != ENOENT)
3520 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3521
3522 continue;
3523 }
3524
3525 free(name);
117dcc57
ZJS		 3526 name = sysv_translate_name(de->d_name + 3);
3527 if (!name) {
3528 r = log_oom();
2c4104f0
LP		 3529 goto finish;
3530 }
3531
66870f90
ZJS		 3532 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3533 if (r < 0) {
fbe9f3a9
LP		 3534 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3535 continue;
3536 }
2c4104f0 3537
c68364b7
LP		 3538 if (de->d_name[0] == 'S') {
3539
3cdebc21 3540 if (rcnd_table[i].type == RUNLEVEL_UP) {
ea87ca5a
LP		 3541 SERVICE(service)->sysv_start_priority_from_rcnd =
3542 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
db06e3b6 3543
c68364b7 3544 SERVICE(service)->sysv_enabled = true;
f73d93a4 3545 }
db06e3b6 3546
117dcc57
ZJS		 3547 r = set_ensure_allocated(&runlevel_services[i],
3548 trivial_hash_func, trivial_compare_func);
3549 if (r < 0)
c68364b7 3550 goto finish;
2c4104f0 3551
117dcc57
ZJS		 3552 r = set_put(runlevel_services[i], service);
3553 if (r < 0)
2c4104f0 3554 goto finish;
23a177ef 3555
fc5df99e 3556 } else if (de->d_name[0] == 'K' &&
3cdebc21 3557 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
6542952f 3558
117dcc57
ZJS		 3559 r = set_ensure_allocated(&shutdown_services,
3560 trivial_hash_func, trivial_compare_func);
3561 if (r < 0)
c68364b7
LP		 3562 goto finish;
3563
117dcc57
ZJS		 3564 r = set_put(shutdown_services, service);
3565 if (r < 0)
2c4104f0
LP		 3566 goto finish;
3567 }
3568 }
3569 }
3570
c68364b7
LP		 3571 /* Now we loaded all stubs and are aware of the lowest
3572 start-up priority for all services, not let's actually load
3573 the services, this will also tell us which services are
3574 actually native now */
3575 manager_dispatch_load_queue(m);
3576
3577 /* If this is a native service, rely on native ways to pull in
3578 * a service, don't pull it in via sysv rcN.d links. */
3579 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3580 SET_FOREACH(service, runlevel_services[i], j) {
3581 service = unit_follow_merge(service);
3582
ac155bb8 3583 if (service->fragment_path)
c68364b7
LP		 3584 continue;
3585
117dcc57
ZJS		 3586 r = unit_add_two_dependencies_by_name_inverse(
3587 service, UNIT_AFTER, UNIT_WANTS,
3588 rcnd_table[i].target, NULL, true);
3589 if (r < 0)
c68364b7
LP		 3590 goto finish;
3591 }
3592
3593 /* We honour K links only for halt/reboot. For the normal
3594 * runlevels we assume the stop jobs will be implicitly added
35b8ca3a 3595 * by the core logic. Also, we don't really distinguish here
c68364b7 3596 * between the runlevels 0 and 6 and just add them to the
3cdebc21 3597 * special shutdown target. */
c68364b7
LP		 3598 SET_FOREACH(service, shutdown_services, j) {
3599 service = unit_follow_merge(service);
3600
ac155bb8 3601 if (service->fragment_path)
c68364b7
LP		 3602 continue;
3603
117dcc57
ZJS		 3604 r = unit_add_two_dependencies_by_name(
3605 service, UNIT_BEFORE, UNIT_CONFLICTS,
3606 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3607 if (r < 0)
c68364b7
LP		 3608 goto finish;
3609 }
3610
2c4104f0
LP		 3611 r = 0;
3612
3613finish:
fbe9f3a9 3614
c68364b7
LP		 3615 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3616 set_free(runlevel_services[i]);
2c4104f0
LP		 3617
3618 return r;
3619}
07459bb6 3620#endif
2c4104f0 3621
05e343b7
LP		 3622static void service_bus_name_owner_change(
3623 Unit *u,
3624 const char *name,
3625 const char *old_owner,
3626 const char *new_owner) {
3627
3628 Service *s = SERVICE(u);
3629
3630 assert(s);
3631 assert(name);
3632
3633 assert(streq(s->bus_name, name));
3634 assert(old_owner || new_owner);
3635
3636 if (old_owner && new_owner)
66870f90
ZJS		 3637 log_debug_unit(u->id,
3638 "%s's D-Bus name %s changed owner from %s to %s",
3639 u->id, name, old_owner, new_owner);
05e343b7 3640 else if (old_owner)
66870f90
ZJS		 3641 log_debug_unit(u->id,
3642 "%s's D-Bus name %s no longer registered by %s",
3643 u->id, name, old_owner);
05e343b7 3644 else
66870f90
ZJS		 3645 log_debug_unit(u->id,
3646 "%s's D-Bus name %s now registered by %s",
3647 u->id, name, new_owner);
05e343b7
LP		 3648
3649 s->bus_name_good = !!new_owner;
3650
3651 if (s->type == SERVICE_DBUS) {
3652
3653 /* service_enter_running() will figure out what to
3654 * do */
3655 if (s->state == SERVICE_RUNNING)
f42806df 3656 service_enter_running(s, SERVICE_SUCCESS);
05e343b7
LP		 3657 else if (s->state == SERVICE_START && new_owner)
3658 service_enter_start_post(s);
3659
3660 } else if (new_owner &&
3661 s->main_pid <= 0 &&
3662 (s->state == SERVICE_START ||
3663 s->state == SERVICE_START_POST ||
3664 s->state == SERVICE_RUNNING ||
3665 s->state == SERVICE_RELOAD)) {
3666
3667 /* Try to acquire PID from bus service */
66870f90
ZJS		 3668 log_debug_unit(u->id,
3669 "Trying to acquire PID from D-Bus name...");
05e343b7 3670
ac155bb8 3671 bus_query_pid(u->manager, name);
05e343b7
LP		 3672 }
3673}
3674
3675static void service_bus_query_pid_done(
3676 Unit *u,
3677 const char *name,
3678 pid_t pid) {
3679
3680 Service *s = SERVICE(u);
3681
3682 assert(s);
3683 assert(name);
3684
66870f90
ZJS		 3685 log_debug_unit(u->id,
3686 "%s's D-Bus name %s is now owned by process %u",
3687 u->id, name, (unsigned) pid);
05e343b7
LP		 3688
3689 if (s->main_pid <= 0 &&
3690 (s->state == SERVICE_START ||
3691 s->state == SERVICE_START_POST ||
3692 s->state == SERVICE_RUNNING ||
3693 s->state == SERVICE_RELOAD))
5925dd3c 3694 service_set_main_pid(s, pid);
05e343b7
LP		 3695}
3696
6cf6bbc2 3697int service_set_socket_fd(Service *s, int fd, Socket *sock) {
57020a3a 3698
4f2d528d
LP		 3699 assert(s);
3700 assert(fd >= 0);
3701
3702 /* This is called by the socket code when instantiating a new
3703 * service for a stream socket and the socket needs to be
3704 * configured. */
3705
1124fe6f 3706 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 3707 return -EINVAL;
3708
3709 if (s->socket_fd >= 0)
3710 return -EBUSY;
3711
3712 if (s->state != SERVICE_DEAD)
3713 return -EAGAIN;
3714
3715 s->socket_fd = fd;
701cc384 3716 s->got_socket_fd = true;
6cf6bbc2 3717
57020a3a
LP		 3718 unit_ref_set(&s->accept_socket, UNIT(sock));
3719
3720 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
4f2d528d
LP		 3721}
3722
fdf20a31 3723static void service_reset_failed(Unit *u) {
5632e374
LP		 3724 Service *s = SERVICE(u);
3725
3726 assert(s);
3727
fdf20a31 3728 if (s->state == SERVICE_FAILED)
5632e374
LP		 3729 service_set_state(s, SERVICE_DEAD);
3730
f42806df
LP		 3731 s->result = SERVICE_SUCCESS;
3732 s->reload_result = SERVICE_SUCCESS;
451b34cc
LP		 3733
3734 RATELIMIT_RESET(s->start_limit);
5632e374
LP		 3735}
3736
c74f17d9 3737static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
8a0867d6 3738 Service *s = SERVICE(u);
814cc562 3739 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
8a0867d6
LP		 3740}
3741
94f04347
LP		 3742static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3743 [SERVICE_DEAD] = "dead",
3744 [SERVICE_START_PRE] = "start-pre",
3745 [SERVICE_START] = "start",
3746 [SERVICE_START_POST] = "start-post",
3747 [SERVICE_RUNNING] = "running",
80876c20 3748 [SERVICE_EXITED] = "exited",
94f04347
LP		 3749 [SERVICE_RELOAD] = "reload",
3750 [SERVICE_STOP] = "stop",
3751 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3752 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3753 [SERVICE_STOP_POST] = "stop-post",
3754 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3755 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 3756 [SERVICE_FAILED] = "failed",
94f04347
LP		 3757 [SERVICE_AUTO_RESTART] = "auto-restart",
3758};
3759
3760DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3761
3762static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
525ee6f4
LP		 3763 [SERVICE_RESTART_NO] = "no",
3764 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
50caaedb
LP		 3765 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3766 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3767 [SERVICE_RESTART_ALWAYS] = "always"
94f04347
LP		 3768};
3769
3770DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3771
3772static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
94f04347 3773 [SERVICE_SIMPLE] = "simple",
0d624a78 3774 [SERVICE_FORKING] = "forking",
34e9ba66 3775 [SERVICE_ONESHOT] = "oneshot",
8c47c732 3776 [SERVICE_DBUS] = "dbus",
f2b68789
LP		 3777 [SERVICE_NOTIFY] = "notify",
3778 [SERVICE_IDLE] = "idle"
94f04347
LP		 3779};
3780
3781DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3782
e537352b 3783static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
94f04347
LP		 3784 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3785 [SERVICE_EXEC_START] = "ExecStart",
3786 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3787 [SERVICE_EXEC_RELOAD] = "ExecReload",
3788 [SERVICE_EXEC_STOP] = "ExecStop",
3789 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3790};
3791
3792DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3793
c952c6ec
LP		 3794static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3795 [NOTIFY_NONE] = "none",
3796 [NOTIFY_MAIN] = "main",
3797 [NOTIFY_ALL] = "all"
3798};
3799
3800DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3801
f42806df
LP		 3802static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3803 [SERVICE_SUCCESS] = "success",
3804 [SERVICE_FAILURE_RESOURCES] = "resources",
3805 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3806 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3807 [SERVICE_FAILURE_SIGNAL] = "signal",
bb242b7b 3808 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
8d1b002a
LP		 3809 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3810 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
f42806df
LP		 3811};
3812
3813DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3814
4b939747
MO		 3815static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3816 [SERVICE_START_LIMIT_NONE] = "none",
3817 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3818 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3819 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3820};
3821DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3822
87f0e418 3823const UnitVTable service_vtable = {
7d17cfbc 3824 .object_size = sizeof(Service),
3ef63c31 3825
f975e971
LP		 3826 .sections =
3827 "Unit\0"
3828 "Service\0"
3829 "Install\0",
5cb5a6ff 3830
71645aca
LP		 3831 .exec_context_offset = offsetof(Service, exec_context),
3832 .exec_section = "Service",
3833
034c6ed7
LP		 3834 .init = service_init,
3835 .done = service_done,
a16e1123
LP		 3836 .load = service_load,
3837
3838 .coldplug = service_coldplug,
034c6ed7 3839
5cb5a6ff
LP		 3840 .dump = service_dump,
3841
3842 .start = service_start,
3843 .stop = service_stop,
3844 .reload = service_reload,
3845
034c6ed7
LP		 3846 .can_reload = service_can_reload,
3847
8a0867d6
LP		 3848 .kill = service_kill,
3849
a16e1123
LP		 3850 .serialize = service_serialize,
3851 .deserialize_item = service_deserialize_item,
3852
5cb5a6ff 3853 .active_state = service_active_state,
10a94420 3854 .sub_state_to_string = service_sub_state_to_string,
5cb5a6ff 3855
701cc384
LP		 3856 .check_gc = service_check_gc,
3857 .check_snapshot = service_check_snapshot,
3858
034c6ed7
LP		 3859 .sigchld_event = service_sigchld_event,
3860 .timer_event = service_timer_event,
3a111838 3861 .fd_event = service_fd_event,
2c4104f0 3862
fdf20a31 3863 .reset_failed = service_reset_failed,
5632e374 3864
8e274523 3865 .cgroup_notify_empty = service_cgroup_notify_event,
8c47c732 3866 .notify_message = service_notify_message,
8e274523 3867
05e343b7
LP		 3868 .bus_name_owner_change = service_bus_name_owner_change,
3869 .bus_query_pid_done = service_bus_query_pid_done,
3870
c4e2ceae 3871 .bus_interface = "org.freedesktop.systemd1.Service",
4139c1b2 3872 .bus_message_handler = bus_service_message_handler,
c4e2ceae 3873 .bus_invalidating_properties = bus_service_invalidating_properties,
4139c1b2 3874
07459bb6 3875#ifdef HAVE_SYSV_COMPAT
c6918296 3876 .enumerate = service_enumerate,
07459bb6 3877#endif
c6918296
MS		 3878 .status_message_formats = {
3879 .starting_stopping = {
3880 [0] = "Starting %s...",
3881 [1] = "Stopping %s...",
3882 },
3883 .finished_start_job = {
3884 [JOB_DONE] = "Started %s.",
3885 [JOB_FAILED] = "Failed to start %s.",
3886 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3887 [JOB_TIMEOUT] = "Timed out starting %s.",
3888 },
3889 .finished_stop_job = {
3890 [JOB_DONE] = "Stopped %s.",
3891 [JOB_FAILED] = "Stopped (with error) %s.",
3892 [JOB_TIMEOUT] = "Timed out stopping %s.",
3893 },
3894 },
5cb5a6ff 3895};
Unnamed repository; edit this file 'description' to name the repository.