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