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