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