src/core/service.c

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