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         RATELIMIT_INIT(s->start_limit,
 151                        u->manager->default_start_limit_interval,
 152                        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_timestamp.monotonic + s->watchdog_usec, 0, service_dispatch_watchdog, s, &s->watchdog_event_source);
 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, now(CLOCK_MONOTONIC) + usec, 0, service_dispatch_timer, s, &s->timer_event_source);
 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_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 (kill(pid, 0) < 0 && errno != EPERM) {
1372                 if (may_warn)
1373                         log_info_unit(UNIT(s)->id,
1374                                       "PID "PID_FMT" read from file %s does not exist.",
1375                                       pid, s->pid_file);
1376                 return -ESRCH;
1377         }
1378
1379         if (s->main_pid_known) {
1380                 if (pid == s->main_pid)
1381                         return 0;
1382
1383                 log_debug_unit(UNIT(s)->id,
1384                                "Main PID changing: "PID_FMT" -> "PID_FMT,
1385                                s->main_pid, pid);
1386                 service_unwatch_main_pid(s);
1387                 s->main_pid_known = false;
1388         } else
1389                 log_debug_unit(UNIT(s)->id,
1390                                "Main PID loaded: "PID_FMT, pid);
1391
1392         r = service_set_main_pid(s, pid);
1393         if (r < 0)
1394                 return r;
1395
1396         r = unit_watch_pid(UNIT(s), pid);
1397         if (r < 0) {
1398                 /* FIXME: we need to do something here */
1399                 log_warning_unit(UNIT(s)->id,
1400                                  "Failed to watch PID "PID_FMT" from service %s",
1401                                  pid, UNIT(s)->id);
1402                 return r;
1403         }
1404
1405         return 0;
1406 }
1407
1408 static int service_search_main_pid(Service *s) {
1409         pid_t pid;
1410         int r;
1411
1412         assert(s);
1413
1414         /* If we know it anyway, don't ever fallback to unreliable
1415          * heuristics */
1416         if (s->main_pid_known)
1417                 return 0;
1418
1419         if (!s->guess_main_pid)
1420                 return 0;
1421
1422         assert(s->main_pid <= 0);
1423
1424         pid = unit_search_main_pid(UNIT(s));
1425         if (pid <= 0)
1426                 return -ENOENT;
1427
1428         log_debug_unit(UNIT(s)->id,
1429                        "Main PID guessed: "PID_FMT, pid);
1430         r = service_set_main_pid(s, pid);
1431         if (r < 0)
1432                 return r;
1433
1434         r = unit_watch_pid(UNIT(s), pid);
1435         if (r < 0)
1436                 /* FIXME: we need to do something here */
1437                 log_warning_unit(UNIT(s)->id,
1438                                  "Failed to watch PID "PID_FMT" from service %s",
1439                                  pid, UNIT(s)->id);
1440                 return r;
1441
1442         return 0;
1443 }
1444
1445 static void service_set_state(Service *s, ServiceState state) {
1446         ServiceState old_state;
1447         const UnitActiveState *table;
1448
1449         assert(s);
1450
1451         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1452
1453         old_state = s->state;
1454         s->state = state;
1455
1456         service_unwatch_pid_file(s);
1457
1458         if (!IN_SET(state,
1459                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1460                     SERVICE_RELOAD,
1461                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1462                     SERVICE_STOP_POST,
1463                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1464                     SERVICE_AUTO_RESTART))
1465                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1466
1467         if (!IN_SET(state,
1468                     SERVICE_START, SERVICE_START_POST,
1469                     SERVICE_RUNNING, SERVICE_RELOAD,
1470                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1471                     SERVICE_STOP_POST,
1472                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1473                 service_unwatch_main_pid(s);
1474                 s->main_command = NULL;
1475         }
1476
1477         if (!IN_SET(state,
1478                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1479                     SERVICE_RELOAD,
1480                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1481                     SERVICE_STOP_POST,
1482                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1483                 service_unwatch_control_pid(s);
1484                 s->control_command = NULL;
1485                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1486         }
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_valid(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_valid(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_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1591                         service_start_watchdog(s);
1592
1593                 service_set_state(s, s->deserialized_state);
1594         }
1595
1596         return 0;
1597 }
1598
1599 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1600         Iterator i;
1601         int r;
1602         int *rfds = NULL;
1603         unsigned rn_fds = 0;
1604         Unit *u;
1605
1606         assert(s);
1607         assert(fds);
1608         assert(n_fds);
1609
1610         if (s->socket_fd >= 0)
1611                 return 0;
1612
1613         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1614                 int *cfds;
1615                 unsigned cn_fds;
1616                 Socket *sock;
1617
1618                 if (u->type != UNIT_SOCKET)
1619                         continue;
1620
1621                 sock = SOCKET(u);
1622
1623                 r = socket_collect_fds(sock, &cfds, &cn_fds);
1624                 if (r < 0)
1625                         goto fail;
1626
1627                 if (!cfds)
1628                         continue;
1629
1630                 if (!rfds) {
1631                         rfds = cfds;
1632                         rn_fds = cn_fds;
1633                 } else {
1634                         int *t;
1635
1636                         t = new(int, rn_fds+cn_fds);
1637                         if (!t) {
1638                                 free(cfds);
1639                                 r = -ENOMEM;
1640                                 goto fail;
1641                         }
1642
1643                         memcpy(t, rfds, rn_fds * sizeof(int));
1644                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1645                         free(rfds);
1646                         free(cfds);
1647
1648                         rfds = t;
1649                         rn_fds = rn_fds+cn_fds;
1650                 }
1651         }
1652
1653         *fds = rfds;
1654         *n_fds = rn_fds;
1655
1656         return 0;
1657
1658 fail:
1659         free(rfds);
1660
1661         return r;
1662 }
1663
1664 static int service_spawn(
1665                 Service *s,
1666                 ExecCommand *c,
1667                 bool timeout,
1668                 bool pass_fds,
1669                 bool apply_permissions,
1670                 bool apply_chroot,
1671                 bool apply_tty_stdin,
1672                 bool set_notify_socket,
1673                 bool is_control,
1674                 pid_t *_pid) {
1675
1676         pid_t pid;
1677         int r;
1678         int *fds = NULL;
1679         _cleanup_free_ int *fdsbuf = NULL;
1680         unsigned n_fds = 0, n_env = 0;
1681         _cleanup_strv_free_ char
1682                 **argv = NULL, **final_env = NULL, **our_env = NULL;
1683         const char *path;
1684
1685         assert(s);
1686         assert(c);
1687         assert(_pid);
1688
1689         unit_realize_cgroup(UNIT(s));
1690
1691         r = unit_setup_exec_runtime(UNIT(s));
1692         if (r < 0)
1693                 goto fail;
1694
1695         if (pass_fds ||
1696             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1697             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1698             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1699
1700                 if (s->socket_fd >= 0) {
1701                         fds = &s->socket_fd;
1702                         n_fds = 1;
1703                 } else {
1704                         r = service_collect_fds(s, &fdsbuf, &n_fds);
1705                         if (r < 0)
1706                                 goto fail;
1707
1708                         fds = fdsbuf;
1709                 }
1710         }
1711
1712         if (timeout && s->timeout_start_usec > 0) {
1713                 r = service_arm_timer(s, s->timeout_start_usec);
1714                 if (r < 0)
1715                         goto fail;
1716         } else
1717                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1718
1719         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1720         if (r < 0)
1721                 goto fail;
1722
1723         our_env = new0(char*, 4);
1724         if (!our_env) {
1725                 r = -ENOMEM;
1726                 goto fail;
1727         }
1728
1729         if (set_notify_socket)
1730                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1731                         r = -ENOMEM;
1732                         goto fail;
1733                 }
1734
1735         if (s->main_pid > 0)
1736                 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1737                         r = -ENOMEM;
1738                         goto fail;
1739                 }
1740
1741         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1742                 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1743                         r = -ENOMEM;
1744                         goto fail;
1745                 }
1746
1747         final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1748         if (!final_env) {
1749                 r = -ENOMEM;
1750                 goto fail;
1751         }
1752
1753         if (is_control && UNIT(s)->cgroup_path) {
1754                 path = strappenda(UNIT(s)->cgroup_path, "/control");
1755                 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1756         } else
1757                 path = UNIT(s)->cgroup_path;
1758
1759         r = exec_spawn(c,
1760                        argv,
1761                        &s->exec_context,
1762                        fds, n_fds,
1763                        final_env,
1764                        apply_permissions,
1765                        apply_chroot,
1766                        apply_tty_stdin,
1767                        UNIT(s)->manager->confirm_spawn,
1768                        UNIT(s)->manager->cgroup_supported,
1769                        path,
1770                        UNIT(s)->id,
1771                        s->watchdog_usec,
1772                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1773                        s->exec_runtime,
1774                        &pid);
1775         if (r < 0)
1776                 goto fail;
1777
1778         r = unit_watch_pid(UNIT(s), pid);
1779         if (r < 0)
1780                 /* FIXME: we need to do something here */
1781                 goto fail;
1782
1783         *_pid = pid;
1784
1785         return 0;
1786
1787 fail:
1788         if (timeout)
1789                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1790
1791         return r;
1792 }
1793
1794 static int main_pid_good(Service *s) {
1795         assert(s);
1796
1797         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1798          * don't know */
1799
1800         /* If we know the pid file, then lets just check if it is
1801          * still valid */
1802         if (s->main_pid_known) {
1803
1804                 /* If it's an alien child let's check if it is still
1805                  * alive ... */
1806                 if (s->main_pid_alien && s->main_pid > 0)
1807                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1808
1809                 /* .. otherwise assume we'll get a SIGCHLD for it,
1810                  * which we really should wait for to collect exit
1811                  * status and code */
1812                 return s->main_pid > 0;
1813         }
1814
1815         /* We don't know the pid */
1816         return -EAGAIN;
1817 }
1818
1819 _pure_ static int control_pid_good(Service *s) {
1820         assert(s);
1821
1822         return s->control_pid > 0;
1823 }
1824
1825 static int cgroup_good(Service *s) {
1826         int r;
1827
1828         assert(s);
1829
1830         if (!UNIT(s)->cgroup_path)
1831                 return 0;
1832
1833         r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1834         if (r < 0)
1835                 return r;
1836
1837         return !r;
1838 }
1839
1840 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1841         int r;
1842         assert(s);
1843
1844         if (f != SERVICE_SUCCESS)
1845                 s->result = f;
1846
1847         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1848
1849         if (allow_restart &&
1850             !s->forbid_restart &&
1851             (s->restart == SERVICE_RESTART_ALWAYS ||
1852              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1853              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1854              (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1855              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1856                                                          s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1857             (s->result != SERVICE_FAILURE_EXIT_CODE ||
1858              !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1859             (s->result != SERVICE_FAILURE_SIGNAL ||
1860              !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1861
1862                 r = service_arm_timer(s, s->restart_usec);
1863                 if (r < 0)
1864                         goto fail;
1865
1866                 service_set_state(s, SERVICE_AUTO_RESTART);
1867         }
1868
1869         s->forbid_restart = false;
1870
1871         /* we want fresh tmpdirs in case service is started again immediately */
1872         exec_runtime_destroy(s->exec_runtime);
1873         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1874
1875         /* Try to delete the pid file. At this point it will be
1876          * out-of-date, and some software might be confused by it, so
1877          * let's remove it. */
1878         if (s->pid_file)
1879                 unlink_noerrno(s->pid_file);
1880
1881         return;
1882
1883 fail:
1884         log_warning_unit(UNIT(s)->id,
1885                          "%s failed to run install restart timer: %s",
1886                          UNIT(s)->id, strerror(-r));
1887         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1888 }
1889
1890 static void service_enter_stop_post(Service *s, ServiceResult f) {
1891         int r;
1892         assert(s);
1893
1894         if (f != SERVICE_SUCCESS)
1895                 s->result = f;
1896
1897         service_unwatch_control_pid(s);
1898
1899         s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1900         if (s->control_command) {
1901                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1902
1903                 r = service_spawn(s,
1904                                   s->control_command,
1905                                   true,
1906                                   false,
1907                                   !s->permissions_start_only,
1908                                   !s->root_directory_start_only,
1909                                   true,
1910                                   false,
1911                                   true,
1912                                   &s->control_pid);
1913                 if (r < 0)
1914                         goto fail;
1915
1916                 service_set_state(s, SERVICE_STOP_POST);
1917         } else
1918                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1919
1920         return;
1921
1922 fail:
1923         log_warning_unit(UNIT(s)->id,
1924                          "%s failed to run 'stop-post' task: %s",
1925                          UNIT(s)->id, strerror(-r));
1926         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1927 }
1928
1929 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1930         int r;
1931
1932         assert(s);
1933
1934         if (f != SERVICE_SUCCESS)
1935                 s->result = f;
1936
1937         r = unit_kill_context(
1938                         UNIT(s),
1939                         &s->kill_context,
1940                         state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1941                         s->main_pid,
1942                         s->control_pid,
1943                         s->main_pid_alien);
1944
1945         if (r < 0)
1946                 goto fail;
1947
1948         if (r > 0) {
1949                 if (s->timeout_stop_usec > 0) {
1950                         r = service_arm_timer(s, s->timeout_stop_usec);
1951                         if (r < 0)
1952                                 goto fail;
1953                 }
1954
1955                 service_set_state(s, state);
1956         } else if (state == SERVICE_STOP_SIGTERM)
1957                 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1958         else if (state == SERVICE_STOP_SIGKILL)
1959                 service_enter_stop_post(s, SERVICE_SUCCESS);
1960         else if (state == SERVICE_FINAL_SIGTERM)
1961                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1962         else
1963                 service_enter_dead(s, SERVICE_SUCCESS, true);
1964
1965         return;
1966
1967 fail:
1968         log_warning_unit(UNIT(s)->id,
1969                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1970
1971         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1972                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1973         else
1974                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1975 }
1976
1977 static void service_enter_stop(Service *s, ServiceResult f) {
1978         int r;
1979
1980         assert(s);
1981
1982         if (f != SERVICE_SUCCESS)
1983                 s->result = f;
1984
1985         service_unwatch_control_pid(s);
1986
1987         s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1988         if (s->control_command) {
1989                 s->control_command_id = SERVICE_EXEC_STOP;
1990
1991                 r = service_spawn(s,
1992                                   s->control_command,
1993                                   true,
1994                                   false,
1995                                   !s->permissions_start_only,
1996                                   !s->root_directory_start_only,
1997                                   false,
1998                                   false,
1999                                   true,
2000                                   &s->control_pid);
2001                 if (r < 0)
2002                         goto fail;
2003
2004                 service_set_state(s, SERVICE_STOP);
2005         } else
2006                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2007
2008         return;
2009
2010 fail:
2011         log_warning_unit(UNIT(s)->id,
2012                          "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2013         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2014 }
2015
2016 static void service_enter_running(Service *s, ServiceResult f) {
2017         int main_pid_ok, cgroup_ok;
2018         assert(s);
2019
2020         if (f != SERVICE_SUCCESS)
2021                 s->result = f;
2022
2023         main_pid_ok = main_pid_good(s);
2024         cgroup_ok = cgroup_good(s);
2025
2026         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2027             (s->bus_name_good || s->type != SERVICE_DBUS))
2028                 service_set_state(s, SERVICE_RUNNING);
2029         else if (s->remain_after_exit)
2030                 service_set_state(s, SERVICE_EXITED);
2031         else
2032                 service_enter_stop(s, SERVICE_SUCCESS);
2033 }
2034
2035 static void service_enter_start_post(Service *s) {
2036         int r;
2037         assert(s);
2038
2039         service_unwatch_control_pid(s);
2040         service_reset_watchdog(s);
2041
2042         s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2043         if (s->control_command) {
2044                 s->control_command_id = SERVICE_EXEC_START_POST;
2045
2046                 r = service_spawn(s,
2047                                   s->control_command,
2048                                   true,
2049                                   false,
2050                                   !s->permissions_start_only,
2051                                   !s->root_directory_start_only,
2052                                   false,
2053                                   false,
2054                                   true,
2055                                   &s->control_pid);
2056                 if (r < 0)
2057                         goto fail;
2058
2059                 service_set_state(s, SERVICE_START_POST);
2060         } else
2061                 service_enter_running(s, SERVICE_SUCCESS);
2062
2063         return;
2064
2065 fail:
2066         log_warning_unit(UNIT(s)->id,
2067                          "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2068         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2069 }
2070
2071 static void service_kill_control_processes(Service *s) {
2072         char *p;
2073
2074         if (!UNIT(s)->cgroup_path)
2075                 return;
2076
2077         p = strappenda(UNIT(s)->cgroup_path, "/control");
2078         cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2079 }
2080
2081 static void service_enter_start(Service *s) {
2082         ExecCommand *c;
2083         pid_t pid;
2084         int r;
2085
2086         assert(s);
2087
2088         assert(s->exec_command[SERVICE_EXEC_START]);
2089         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2090
2091         service_unwatch_control_pid(s);
2092         service_unwatch_main_pid(s);
2093
2094         /* We want to ensure that nobody leaks processes from
2095          * START_PRE here, so let's go on a killing spree, People
2096          * should not spawn long running processes from START_PRE. */
2097         service_kill_control_processes(s);
2098
2099         if (s->type == SERVICE_FORKING) {
2100                 s->control_command_id = SERVICE_EXEC_START;
2101                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2102
2103                 s->main_command = NULL;
2104         } else {
2105                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2106                 s->control_command = NULL;
2107
2108                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2109         }
2110
2111         r = service_spawn(s,
2112                           c,
2113                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2114                             s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2115                           true,
2116                           true,
2117                           true,
2118                           true,
2119                           s->notify_access != NOTIFY_NONE,
2120                           false,
2121                           &pid);
2122         if (r < 0)
2123                 goto fail;
2124
2125         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2126                 /* For simple services we immediately start
2127                  * the START_POST binaries. */
2128
2129                 service_set_main_pid(s, pid);
2130                 service_enter_start_post(s);
2131
2132         } else  if (s->type == SERVICE_FORKING) {
2133
2134                 /* For forking services we wait until the start
2135                  * process exited. */
2136
2137                 s->control_pid = pid;
2138                 service_set_state(s, SERVICE_START);
2139
2140         } else if (s->type == SERVICE_ONESHOT ||
2141                    s->type == SERVICE_DBUS ||
2142                    s->type == SERVICE_NOTIFY) {
2143
2144                 /* For oneshot services we wait until the start
2145                  * process exited, too, but it is our main process. */
2146
2147                 /* For D-Bus services we know the main pid right away,
2148                  * but wait for the bus name to appear on the
2149                  * bus. Notify services are similar. */
2150
2151                 service_set_main_pid(s, pid);
2152                 service_set_state(s, SERVICE_START);
2153         } else
2154                 assert_not_reached("Unknown service type");
2155
2156         return;
2157
2158 fail:
2159         log_warning_unit(UNIT(s)->id,
2160                          "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2161         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2162 }
2163
2164 static void service_enter_start_pre(Service *s) {
2165         int r;
2166
2167         assert(s);
2168
2169         service_unwatch_control_pid(s);
2170
2171         s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2172         if (s->control_command) {
2173                 /* Before we start anything, let's clear up what might
2174                  * be left from previous runs. */
2175                 service_kill_control_processes(s);
2176
2177                 s->control_command_id = SERVICE_EXEC_START_PRE;
2178
2179                 r = service_spawn(s,
2180                                   s->control_command,
2181                                   true,
2182                                   false,
2183                                   !s->permissions_start_only,
2184                                   !s->root_directory_start_only,
2185                                   true,
2186                                   false,
2187                                   true,
2188                                   &s->control_pid);
2189                 if (r < 0)
2190                         goto fail;
2191
2192                 service_set_state(s, SERVICE_START_PRE);
2193         } else
2194                 service_enter_start(s);
2195
2196         return;
2197
2198 fail:
2199         log_warning_unit(UNIT(s)->id,
2200                          "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2201         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2202 }
2203
2204 static void service_enter_restart(Service *s) {
2205         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2206         int r;
2207
2208         assert(s);
2209
2210         if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2211                 /* Don't restart things if we are going down anyway */
2212                 log_info_unit(UNIT(s)->id,
2213                               "Stop job pending for unit, delaying automatic restart.");
2214
2215                 r = service_arm_timer(s, s->restart_usec);
2216                 if (r < 0)
2217                         goto fail;
2218
2219                 return;
2220         }
2221
2222         /* Any units that are bound to this service must also be
2223          * restarted. We use JOB_RESTART (instead of the more obvious
2224          * JOB_START) here so that those dependency jobs will be added
2225          * as well. */
2226         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2227         if (r < 0)
2228                 goto fail;
2229
2230         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2231          * it will be canceled as part of the service_stop() call that
2232          * is executed as part of JOB_RESTART. */
2233
2234         log_debug_unit(UNIT(s)->id,
2235                        "%s scheduled restart job.", UNIT(s)->id);
2236         return;
2237
2238 fail:
2239         log_warning_unit(UNIT(s)->id,
2240                          "%s failed to schedule restart job: %s",
2241                          UNIT(s)->id, bus_error_message(&error, -r));
2242         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2243 }
2244
2245 static void service_enter_reload(Service *s) {
2246         int r;
2247
2248         assert(s);
2249
2250         service_unwatch_control_pid(s);
2251
2252         s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2253         if (s->control_command) {
2254                 s->control_command_id = SERVICE_EXEC_RELOAD;
2255
2256                 r = service_spawn(s,
2257                                   s->control_command,
2258                                   true,
2259                                   false,
2260                                   !s->permissions_start_only,
2261                                   !s->root_directory_start_only,
2262                                   false,
2263                                   false,
2264                                   true,
2265                                   &s->control_pid);
2266                 if (r < 0)
2267                         goto fail;
2268
2269                 service_set_state(s, SERVICE_RELOAD);
2270         } else
2271                 service_enter_running(s, SERVICE_SUCCESS);
2272
2273         return;
2274
2275 fail:
2276         log_warning_unit(UNIT(s)->id,
2277                          "%s failed to run 'reload' task: %s",
2278                          UNIT(s)->id, strerror(-r));
2279         s->reload_result = SERVICE_FAILURE_RESOURCES;
2280         service_enter_running(s, SERVICE_SUCCESS);
2281 }
2282
2283 static void service_run_next_control(Service *s) {
2284         int r;
2285
2286         assert(s);
2287         assert(s->control_command);
2288         assert(s->control_command->command_next);
2289
2290         assert(s->control_command_id != SERVICE_EXEC_START);
2291
2292         s->control_command = s->control_command->command_next;
2293         service_unwatch_control_pid(s);
2294
2295         r = service_spawn(s,
2296                           s->control_command,
2297                           true,
2298                           false,
2299                           !s->permissions_start_only,
2300                           !s->root_directory_start_only,
2301                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2302                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2303                           false,
2304                           true,
2305                           &s->control_pid);
2306         if (r < 0)
2307                 goto fail;
2308
2309         return;
2310
2311 fail:
2312         log_warning_unit(UNIT(s)->id,
2313                          "%s failed to run next control task: %s",
2314                          UNIT(s)->id, strerror(-r));
2315
2316         if (s->state == SERVICE_START_PRE)
2317                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2318         else if (s->state == SERVICE_STOP)
2319                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2320         else if (s->state == SERVICE_STOP_POST)
2321                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2322         else if (s->state == SERVICE_RELOAD) {
2323                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2324                 service_enter_running(s, SERVICE_SUCCESS);
2325         } else
2326                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2327 }
2328
2329 static void service_run_next_main(Service *s) {
2330         pid_t pid;
2331         int r;
2332
2333         assert(s);
2334         assert(s->main_command);
2335         assert(s->main_command->command_next);
2336         assert(s->type == SERVICE_ONESHOT);
2337
2338         s->main_command = s->main_command->command_next;
2339         service_unwatch_main_pid(s);
2340
2341         r = service_spawn(s,
2342                           s->main_command,
2343                           true,
2344                           true,
2345                           true,
2346                           true,
2347                           true,
2348                           s->notify_access != NOTIFY_NONE,
2349                           false,
2350                           &pid);
2351         if (r < 0)
2352                 goto fail;
2353
2354         service_set_main_pid(s, pid);
2355
2356         return;
2357
2358 fail:
2359         log_warning_unit(UNIT(s)->id,
2360                          "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2361         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2362 }
2363
2364 static int service_start_limit_test(Service *s) {
2365         assert(s);
2366
2367         if (ratelimit_test(&s->start_limit))
2368                 return 0;
2369
2370         switch (s->start_limit_action) {
2371
2372         case SERVICE_START_LIMIT_NONE:
2373                 log_warning_unit(UNIT(s)->id,
2374                                  "%s start request repeated too quickly, refusing to start.",
2375                                  UNIT(s)->id);
2376                 break;
2377
2378         case SERVICE_START_LIMIT_REBOOT: {
2379                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2380                 int r;
2381
2382                 log_warning_unit(UNIT(s)->id,
2383                                  "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2384
2385                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2386                                             SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2387                                             true, &error, NULL);
2388                 if (r < 0)
2389                         log_error_unit(UNIT(s)->id,
2390                                        "Failed to reboot: %s.", bus_error_message(&error, r));
2391
2392                 break;
2393         }
2394
2395         case SERVICE_START_LIMIT_REBOOT_FORCE:
2396                 log_warning_unit(UNIT(s)->id,
2397                                  "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2398                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2399                 break;
2400
2401         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2402                 log_warning_unit(UNIT(s)->id,
2403                                  "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2404                 sync();
2405                 reboot(RB_AUTOBOOT);
2406                 break;
2407
2408         default:
2409                 log_error_unit(UNIT(s)->id,
2410                                "start limit action=%i", s->start_limit_action);
2411                 assert_not_reached("Unknown StartLimitAction.");
2412         }
2413
2414         return -ECANCELED;
2415 }
2416
2417 static int service_start(Unit *u) {
2418         Service *s = SERVICE(u);
2419         int r;
2420
2421         assert(s);
2422
2423         /* We cannot fulfill this request right now, try again later
2424          * please! */
2425         if (s->state == SERVICE_STOP ||
2426             s->state == SERVICE_STOP_SIGTERM ||
2427             s->state == SERVICE_STOP_SIGKILL ||
2428             s->state == SERVICE_STOP_POST ||
2429             s->state == SERVICE_FINAL_SIGTERM ||
2430             s->state == SERVICE_FINAL_SIGKILL)
2431                 return -EAGAIN;
2432
2433         /* Already on it! */
2434         if (s->state == SERVICE_START_PRE ||
2435             s->state == SERVICE_START ||
2436             s->state == SERVICE_START_POST)
2437                 return 0;
2438
2439         /* A service that will be restarted must be stopped first to
2440          * trigger BindsTo and/or OnFailure dependencies. If a user
2441          * does not want to wait for the holdoff time to elapse, the
2442          * service should be manually restarted, not started. We
2443          * simply return EAGAIN here, so that any start jobs stay
2444          * queued, and assume that the auto restart timer will
2445          * eventually trigger the restart. */
2446         if (s->state == SERVICE_AUTO_RESTART)
2447                 return -EAGAIN;
2448
2449         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2450
2451         /* Make sure we don't enter a busy loop of some kind. */
2452         r = service_start_limit_test(s);
2453         if (r < 0) {
2454                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2455                 return r;
2456         }
2457
2458         s->result = SERVICE_SUCCESS;
2459         s->reload_result = SERVICE_SUCCESS;
2460         s->main_pid_known = false;
2461         s->main_pid_alien = false;
2462         s->forbid_restart = false;
2463
2464         service_enter_start_pre(s);
2465         return 0;
2466 }
2467
2468 static int service_stop(Unit *u) {
2469         Service *s = SERVICE(u);
2470
2471         assert(s);
2472
2473         /* Don't create restart jobs from here. */
2474         s->forbid_restart = true;
2475
2476         /* Already on it */
2477         if (s->state == SERVICE_STOP ||
2478             s->state == SERVICE_STOP_SIGTERM ||
2479             s->state == SERVICE_STOP_SIGKILL ||
2480             s->state == SERVICE_STOP_POST ||
2481             s->state == SERVICE_FINAL_SIGTERM ||
2482             s->state == SERVICE_FINAL_SIGKILL)
2483                 return 0;
2484
2485         /* A restart will be scheduled or is in progress. */
2486         if (s->state == SERVICE_AUTO_RESTART) {
2487                 service_set_state(s, SERVICE_DEAD);
2488                 return 0;
2489         }
2490
2491         /* If there's already something running we go directly into
2492          * kill mode. */
2493         if (s->state == SERVICE_START_PRE ||
2494             s->state == SERVICE_START ||
2495             s->state == SERVICE_START_POST ||
2496             s->state == SERVICE_RELOAD) {
2497                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2498                 return 0;
2499         }
2500
2501         assert(s->state == SERVICE_RUNNING ||
2502                s->state == SERVICE_EXITED);
2503
2504         service_enter_stop(s, SERVICE_SUCCESS);
2505         return 0;
2506 }
2507
2508 static int service_reload(Unit *u) {
2509         Service *s = SERVICE(u);
2510
2511         assert(s);
2512
2513         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2514
2515         service_enter_reload(s);
2516         return 0;
2517 }
2518
2519 _pure_ static bool service_can_reload(Unit *u) {
2520         Service *s = SERVICE(u);
2521
2522         assert(s);
2523
2524         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2525 }
2526
2527 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2528         Service *s = SERVICE(u);
2529
2530         assert(u);
2531         assert(f);
2532         assert(fds);
2533
2534         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2535         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2536         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2537
2538         if (s->control_pid > 0)
2539                 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
2540                                            s->control_pid);
2541
2542         if (s->main_pid_known && s->main_pid > 0)
2543                 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2544
2545         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2546
2547         if (s->status_text)
2548                 unit_serialize_item(u, f, "status-text", s->status_text);
2549
2550         /* FIXME: There's a minor uncleanliness here: if there are
2551          * multiple commands attached here, we will start from the
2552          * first one again */
2553         if (s->control_command_id >= 0)
2554                 unit_serialize_item(u, f, "control-command",
2555                                     service_exec_command_to_string(s->control_command_id));
2556
2557         if (s->socket_fd >= 0) {
2558                 int copy;
2559
2560                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2561                         return copy;
2562
2563                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2564         }
2565
2566         if (s->main_exec_status.pid > 0) {
2567                 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2568                                            s->main_exec_status.pid);
2569                 dual_timestamp_serialize(f, "main-exec-status-start",
2570                                          &s->main_exec_status.start_timestamp);
2571                 dual_timestamp_serialize(f, "main-exec-status-exit",
2572                                          &s->main_exec_status.exit_timestamp);
2573
2574                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2575                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2576                                                    s->main_exec_status.code);
2577                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2578                                                    s->main_exec_status.status);
2579                 }
2580         }
2581         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2582                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2583
2584         if (s->forbid_restart)
2585                 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2586
2587         return 0;
2588 }
2589
2590 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2591         Service *s = SERVICE(u);
2592
2593         assert(u);
2594         assert(key);
2595         assert(value);
2596         assert(fds);
2597
2598         if (streq(key, "state")) {
2599                 ServiceState state;
2600
2601                 state = service_state_from_string(value);
2602                 if (state < 0)
2603                         log_debug_unit(u->id, "Failed to parse state value %s", value);
2604                 else
2605                         s->deserialized_state = state;
2606         } else if (streq(key, "result")) {
2607                 ServiceResult f;
2608
2609                 f = service_result_from_string(value);
2610                 if (f < 0)
2611                         log_debug_unit(u->id, "Failed to parse result value %s", value);
2612                 else if (f != SERVICE_SUCCESS)
2613                         s->result = f;
2614
2615         } else if (streq(key, "reload-result")) {
2616                 ServiceResult f;
2617
2618                 f = service_result_from_string(value);
2619                 if (f < 0)
2620                         log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2621                 else if (f != SERVICE_SUCCESS)
2622                         s->reload_result = f;
2623
2624         } else if (streq(key, "control-pid")) {
2625                 pid_t pid;
2626
2627                 if (parse_pid(value, &pid) < 0)
2628                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2629                 else
2630                         s->control_pid = pid;
2631         } else if (streq(key, "main-pid")) {
2632                 pid_t pid;
2633
2634                 if (parse_pid(value, &pid) < 0)
2635                         log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2636                 else {
2637                         service_set_main_pid(s, pid);
2638                         unit_watch_pid(UNIT(s), pid);
2639                 }
2640         } else if (streq(key, "main-pid-known")) {
2641                 int b;
2642
2643                 b = parse_boolean(value);
2644                 if (b < 0)
2645                         log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2646                 else
2647                         s->main_pid_known = b;
2648         } else if (streq(key, "status-text")) {
2649                 char *t;
2650
2651                 t = strdup(value);
2652                 if (!t)
2653                         log_oom();
2654                 else {
2655                         free(s->status_text);
2656                         s->status_text = t;
2657                 }
2658
2659         } else if (streq(key, "control-command")) {
2660                 ServiceExecCommand id;
2661
2662                 id = service_exec_command_from_string(value);
2663                 if (id < 0)
2664                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2665                 else {
2666                         s->control_command_id = id;
2667                         s->control_command = s->exec_command[id];
2668                 }
2669         } else if (streq(key, "socket-fd")) {
2670                 int fd;
2671
2672                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2673                         log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2674                 else {
2675
2676                         if (s->socket_fd >= 0)
2677                                 close_nointr_nofail(s->socket_fd);
2678                         s->socket_fd = fdset_remove(fds, fd);
2679                 }
2680         } else if (streq(key, "main-exec-status-pid")) {
2681                 pid_t pid;
2682
2683                 if (parse_pid(value, &pid) < 0)
2684                         log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2685                 else
2686                         s->main_exec_status.pid = pid;
2687         } else if (streq(key, "main-exec-status-code")) {
2688                 int i;
2689
2690                 if (safe_atoi(value, &i) < 0)
2691                         log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2692                 else
2693                         s->main_exec_status.code = i;
2694         } else if (streq(key, "main-exec-status-status")) {
2695                 int i;
2696
2697                 if (safe_atoi(value, &i) < 0)
2698                         log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2699                 else
2700                         s->main_exec_status.status = i;
2701         } else if (streq(key, "main-exec-status-start"))
2702                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2703         else if (streq(key, "main-exec-status-exit"))
2704                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2705         else if (streq(key, "watchdog-timestamp"))
2706                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2707         else if (streq(key, "forbid-restart")) {
2708                 int b;
2709
2710                 b = parse_boolean(value);
2711                 if (b < 0)
2712                         log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2713                 else
2714                         s->forbid_restart = b;
2715         } else
2716                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2717
2718         return 0;
2719 }
2720
2721 _pure_ static UnitActiveState service_active_state(Unit *u) {
2722         const UnitActiveState *table;
2723
2724         assert(u);
2725
2726         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2727
2728         return table[SERVICE(u)->state];
2729 }
2730
2731 static const char *service_sub_state_to_string(Unit *u) {
2732         assert(u);
2733
2734         return service_state_to_string(SERVICE(u)->state);
2735 }
2736
2737 static bool service_check_gc(Unit *u) {
2738         Service *s = SERVICE(u);
2739
2740         assert(s);
2741
2742         /* Never clean up services that still have a process around,
2743          * even if the service is formally dead. */
2744         if (cgroup_good(s) > 0 ||
2745             main_pid_good(s) > 0 ||
2746             control_pid_good(s) > 0)
2747                 return true;
2748
2749 #ifdef HAVE_SYSV_COMPAT
2750         if (s->is_sysv)
2751                 return true;
2752 #endif
2753
2754         return false;
2755 }
2756
2757 _pure_ static bool service_check_snapshot(Unit *u) {
2758         Service *s = SERVICE(u);
2759
2760         assert(s);
2761
2762         return (s->socket_fd < 0);
2763 }
2764
2765 static int service_retry_pid_file(Service *s) {
2766         int r;
2767
2768         assert(s->pid_file);
2769         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2770
2771         r = service_load_pid_file(s, false);
2772         if (r < 0)
2773                 return r;
2774
2775         service_unwatch_pid_file(s);
2776
2777         service_enter_running(s, SERVICE_SUCCESS);
2778         return 0;
2779 }
2780
2781 static int service_watch_pid_file(Service *s) {
2782         int r;
2783
2784         log_debug_unit(UNIT(s)->id,
2785                        "Setting watch for %s's PID file %s",
2786                        UNIT(s)->id, s->pid_file_pathspec->path);
2787         r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2788         if (r < 0)
2789                 goto fail;
2790
2791         /* the pidfile might have appeared just before we set the watch */
2792         log_debug_unit(UNIT(s)->id,
2793                        "Trying to read %s's PID file %s in case it changed",
2794                        UNIT(s)->id, s->pid_file_pathspec->path);
2795         service_retry_pid_file(s);
2796
2797         return 0;
2798 fail:
2799         log_error_unit(UNIT(s)->id,
2800                        "Failed to set a watch for %s's PID file %s: %s",
2801                        UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2802         service_unwatch_pid_file(s);
2803         return r;
2804 }
2805
2806 static int service_demand_pid_file(Service *s) {
2807         PathSpec *ps;
2808
2809         assert(s->pid_file);
2810         assert(!s->pid_file_pathspec);
2811
2812         ps = new0(PathSpec, 1);
2813         if (!ps)
2814                 return -ENOMEM;
2815
2816         ps->unit = UNIT(s);
2817         ps->path = strdup(s->pid_file);
2818         if (!ps->path) {
2819                 free(ps);
2820                 return -ENOMEM;
2821         }
2822
2823         path_kill_slashes(ps->path);
2824
2825         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2826          * keep their PID file open all the time. */
2827         ps->type = PATH_MODIFIED;
2828         ps->inotify_fd = -1;
2829
2830         s->pid_file_pathspec = ps;
2831
2832         return service_watch_pid_file(s);
2833 }
2834
2835 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2836         PathSpec *p = userdata;
2837         Service *s;
2838
2839         assert(p);
2840
2841         s = SERVICE(p->unit);
2842
2843         assert(s);
2844         assert(fd >= 0);
2845         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2846         assert(s->pid_file_pathspec);
2847         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2848
2849         log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2850
2851         if (path_spec_fd_event(p, events) < 0)
2852                 goto fail;
2853
2854         if (service_retry_pid_file(s) == 0)
2855                 return 0;
2856
2857         if (service_watch_pid_file(s) < 0)
2858                 goto fail;
2859
2860         return 0;
2861
2862 fail:
2863         service_unwatch_pid_file(s);
2864         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2865         return 0;
2866 }
2867
2868 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2869         Service *s = SERVICE(u);
2870         ServiceResult f;
2871
2872         assert(s);
2873         assert(pid >= 0);
2874
2875         if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2876                                      is_clean_exit_lsb(code, status, &s->success_status))
2877                 f = SERVICE_SUCCESS;
2878         else if (code == CLD_EXITED)
2879                 f = SERVICE_FAILURE_EXIT_CODE;
2880         else if (code == CLD_KILLED)
2881                 f = SERVICE_FAILURE_SIGNAL;
2882         else if (code == CLD_DUMPED)
2883                 f = SERVICE_FAILURE_CORE_DUMP;
2884         else
2885                 assert_not_reached("Unknown code");
2886
2887         if (s->main_pid == pid) {
2888                 /* Forking services may occasionally move to a new PID.
2889                  * As long as they update the PID file before exiting the old
2890                  * PID, they're fine. */
2891                 if (service_load_pid_file(s, false) == 0)
2892                         return;
2893
2894                 s->main_pid = 0;
2895                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2896
2897                 if (s->main_command) {
2898                         /* If this is not a forking service than the
2899                          * main process got started and hence we copy
2900                          * the exit status so that it is recorded both
2901                          * as main and as control process exit
2902                          * status */
2903
2904                         s->main_command->exec_status = s->main_exec_status;
2905
2906                         if (s->main_command->ignore)
2907                                 f = SERVICE_SUCCESS;
2908                 } else if (s->exec_command[SERVICE_EXEC_START]) {
2909
2910                         /* If this is a forked process, then we should
2911                          * ignore the return value if this was
2912                          * configured for the starter process */
2913
2914                         if (s->exec_command[SERVICE_EXEC_START]->ignore)
2915                                 f = SERVICE_SUCCESS;
2916                 }
2917
2918                 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2919                            u->id,
2920                            "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2921                                   u->id, sigchld_code_to_string(code), status,
2922                                   strna(code == CLD_EXITED
2923                                         ? exit_status_to_string(status, EXIT_STATUS_FULL)
2924                                         : signal_to_string(status)),
2925                            "EXIT_CODE=%s", sigchld_code_to_string(code),
2926                            "EXIT_STATUS=%i", status,
2927                            NULL);
2928
2929                 if (f != SERVICE_SUCCESS)
2930                         s->result = f;
2931
2932                 if (s->main_command &&
2933                     s->main_command->command_next &&
2934                     f == SERVICE_SUCCESS) {
2935
2936                         /* There is another command to *
2937                          * execute, so let's do that. */
2938
2939                         log_debug_unit(u->id,
2940                                        "%s running next main command for state %s",
2941                                        u->id, service_state_to_string(s->state));
2942                         service_run_next_main(s);
2943
2944                 } else {
2945
2946                         /* The service exited, so the service is officially
2947                          * gone. */
2948                         s->main_command = NULL;
2949
2950                         switch (s->state) {
2951
2952                         case SERVICE_START_POST:
2953                         case SERVICE_RELOAD:
2954                         case SERVICE_STOP:
2955                                 /* Need to wait until the operation is
2956                                  * done */
2957                                 break;
2958
2959                         case SERVICE_START:
2960                                 if (s->type == SERVICE_ONESHOT) {
2961                                         /* This was our main goal, so let's go on */
2962                                         if (f == SERVICE_SUCCESS)
2963                                                 service_enter_start_post(s);
2964                                         else
2965                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2966                                         break;
2967                                 }
2968
2969                                 /* Fall through */
2970
2971                         case SERVICE_RUNNING:
2972                                 service_enter_running(s, f);
2973                                 break;
2974
2975                         case SERVICE_STOP_SIGTERM:
2976                         case SERVICE_STOP_SIGKILL:
2977
2978                                 if (!control_pid_good(s))
2979                                         service_enter_stop_post(s, f);
2980
2981                                 /* If there is still a control process, wait for that first */
2982                                 break;
2983
2984                         case SERVICE_STOP_POST:
2985                         case SERVICE_FINAL_SIGTERM:
2986                         case SERVICE_FINAL_SIGKILL:
2987
2988                                 if (!control_pid_good(s))
2989                                         service_enter_dead(s, f, true);
2990                                 break;
2991
2992                         default:
2993                                 assert_not_reached("Uh, main process died at wrong time.");
2994                         }
2995                 }
2996
2997         } else if (s->control_pid == pid) {
2998                 s->control_pid = 0;
2999
3000                 if (s->control_command) {
3001                         exec_status_exit(&s->control_command->exec_status,
3002                                          &s->exec_context, pid, code, status);
3003
3004                         if (s->control_command->ignore)
3005                                 f = SERVICE_SUCCESS;
3006                 }
3007
3008                 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3009                               "%s: control process exited, code=%s status=%i",
3010                               u->id, sigchld_code_to_string(code), status);
3011
3012                 if (f != SERVICE_SUCCESS)
3013                         s->result = f;
3014
3015                 /* Immediately get rid of the cgroup, so that the
3016                  * kernel doesn't delay the cgroup empty messages for
3017                  * the service cgroup any longer than necessary */
3018                 service_kill_control_processes(s);
3019
3020                 if (s->control_command &&
3021                     s->control_command->command_next &&
3022                     f == SERVICE_SUCCESS) {
3023
3024                         /* There is another command to *
3025                          * execute, so let's do that. */
3026
3027                         log_debug_unit(u->id,
3028                                        "%s running next control command for state %s",
3029                                        u->id, service_state_to_string(s->state));
3030                         service_run_next_control(s);
3031
3032                 } else {
3033                         /* No further commands for this step, so let's
3034                          * figure out what to do next */
3035
3036                         s->control_command = NULL;
3037                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3038
3039                         log_debug_unit(u->id,
3040                                        "%s got final SIGCHLD for state %s",
3041                                        u->id, service_state_to_string(s->state));
3042
3043                         switch (s->state) {
3044
3045                         case SERVICE_START_PRE:
3046                                 if (f == SERVICE_SUCCESS)
3047                                         service_enter_start(s);
3048                                 else
3049                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3050                                 break;
3051
3052                         case SERVICE_START:
3053                                 if (s->type != SERVICE_FORKING)
3054                                         /* Maybe spurious event due to a reload that changed the type? */
3055                                         break;
3056
3057                                 if (f != SERVICE_SUCCESS) {
3058                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3059                                         break;
3060                                 }
3061
3062                                 if (s->pid_file) {
3063                                         bool has_start_post;
3064                                         int r;
3065
3066                                         /* Let's try to load the pid file here if we can.
3067                                          * The PID file might actually be created by a START_POST
3068                                          * script. In that case don't worry if the loading fails. */
3069
3070                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3071                                         r = service_load_pid_file(s, !has_start_post);
3072                                         if (!has_start_post && r < 0) {
3073                                                 r = service_demand_pid_file(s);
3074                                                 if (r < 0 || !cgroup_good(s))
3075                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3076                                                 break;
3077                                         }
3078                                 } else
3079                                         service_search_main_pid(s);
3080
3081                                 service_enter_start_post(s);
3082                                 break;
3083
3084                         case SERVICE_START_POST:
3085                                 if (f != SERVICE_SUCCESS) {
3086                                         service_enter_stop(s, f);
3087                                         break;
3088                                 }
3089
3090                                 if (s->pid_file) {
3091                                         int r;
3092
3093                                         r = service_load_pid_file(s, true);
3094                                         if (r < 0) {
3095                                                 r = service_demand_pid_file(s);
3096                                                 if (r < 0 || !cgroup_good(s))
3097                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3098                                                 break;
3099                                         }
3100                                 } else
3101                                         service_search_main_pid(s);
3102
3103                                 service_enter_running(s, SERVICE_SUCCESS);
3104                                 break;
3105
3106                         case SERVICE_RELOAD:
3107                                 if (f == SERVICE_SUCCESS) {
3108                                         service_load_pid_file(s, true);
3109                                         service_search_main_pid(s);
3110                                 }
3111
3112                                 s->reload_result = f;
3113                                 service_enter_running(s, SERVICE_SUCCESS);
3114                                 break;
3115
3116                         case SERVICE_STOP:
3117                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3118                                 break;
3119
3120                         case SERVICE_STOP_SIGTERM:
3121                         case SERVICE_STOP_SIGKILL:
3122                                 if (main_pid_good(s) <= 0)
3123                                         service_enter_stop_post(s, f);
3124
3125                                 /* If there is still a service
3126                                  * process around, wait until
3127                                  * that one quit, too */
3128                                 break;
3129
3130                         case SERVICE_STOP_POST:
3131                         case SERVICE_FINAL_SIGTERM:
3132                         case SERVICE_FINAL_SIGKILL:
3133                                 if (main_pid_good(s) <= 0)
3134                                         service_enter_dead(s, f, true);
3135                                 break;
3136
3137                         default:
3138                                 assert_not_reached("Uh, control process died at wrong time.");
3139                         }
3140                 }
3141         }
3142
3143         /* Notify clients about changed exit status */
3144         unit_add_to_dbus_queue(u);
3145 }
3146
3147 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3148         Service *s = SERVICE(userdata);
3149
3150         assert(s);
3151         assert(source == s->timer_event_source);
3152
3153         switch (s->state) {
3154
3155         case SERVICE_START_PRE:
3156         case SERVICE_START:
3157                 log_warning_unit(UNIT(s)->id,
3158                                  "%s %s operation timed out. Terminating.",
3159                                  UNIT(s)->id,
3160                                  s->state == SERVICE_START ? "start" : "start-pre");
3161                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3162                 break;
3163
3164         case SERVICE_START_POST:
3165                 log_warning_unit(UNIT(s)->id,
3166                                  "%s start-post operation timed out. Stopping.", UNIT(s)->id);
3167                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3168                 break;
3169
3170         case SERVICE_RELOAD:
3171                 log_warning_unit(UNIT(s)->id,
3172                                  "%s reload operation timed out. Stopping.", UNIT(s)->id);
3173                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3174                 service_enter_running(s, SERVICE_SUCCESS);
3175                 break;
3176
3177         case SERVICE_STOP:
3178                 log_warning_unit(UNIT(s)->id,
3179                                  "%s stopping timed out. Terminating.", UNIT(s)->id);
3180                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3181                 break;
3182
3183         case SERVICE_STOP_SIGTERM:
3184                 if (s->kill_context.send_sigkill) {
3185                         log_warning_unit(UNIT(s)->id,
3186                                          "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
3187                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3188                 } else {
3189                         log_warning_unit(UNIT(s)->id,
3190                                          "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
3191                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3192                 }
3193
3194                 break;
3195
3196         case SERVICE_STOP_SIGKILL:
3197                 /* Uh, we sent a SIGKILL and it is still not gone?
3198                  * Must be something we cannot kill, so let's just be
3199                  * weirded out and continue */
3200
3201                 log_warning_unit(UNIT(s)->id,
3202                                  "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
3203                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3204                 break;
3205
3206         case SERVICE_STOP_POST:
3207                 log_warning_unit(UNIT(s)->id,
3208                                  "%s stop-post timed out. Terminating.", UNIT(s)->id);
3209                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3210                 break;
3211
3212         case SERVICE_FINAL_SIGTERM:
3213                 if (s->kill_context.send_sigkill) {
3214                         log_warning_unit(UNIT(s)->id,
3215                                          "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
3216                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3217                 } else {
3218                         log_warning_unit(UNIT(s)->id,
3219                                          "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
3220                                          UNIT(s)->id);
3221                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3222                 }
3223
3224                 break;
3225
3226         case SERVICE_FINAL_SIGKILL:
3227                 log_warning_unit(UNIT(s)->id,
3228                                  "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
3229                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3230                 break;
3231
3232         case SERVICE_AUTO_RESTART:
3233                 log_info_unit(UNIT(s)->id,
3234                               "%s holdoff time over, scheduling restart.", UNIT(s)->id);
3235                 service_enter_restart(s);
3236                 break;
3237
3238         default:
3239                 assert_not_reached("Timeout at wrong time.");
3240         }
3241
3242         return 0;
3243 }
3244
3245 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3246         Service *s = SERVICE(userdata);
3247
3248         assert(s);
3249         assert(source == s->watchdog_event_source);
3250
3251         log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
3252         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
3253
3254         return 0;
3255 }
3256
3257 static void service_notify_cgroup_empty_event(Unit *u) {
3258         Service *s = SERVICE(u);
3259
3260         assert(u);
3261
3262         log_debug_unit(u->id, "%s: cgroup is empty", u->id);
3263
3264         switch (s->state) {
3265
3266                 /* Waiting for SIGCHLD is usually more interesting,
3267                  * because it includes return codes/signals. Which is
3268                  * why we ignore the cgroup events for most cases,
3269                  * except when we don't know pid which to expect the
3270                  * SIGCHLD for. */
3271
3272         case SERVICE_START:
3273         case SERVICE_START_POST:
3274                 /* If we were hoping for the daemon to write its PID file,
3275                  * we can give up now. */
3276                 if (s->pid_file_pathspec) {
3277                         log_warning_unit(u->id,
3278                                          "%s never wrote its PID file. Failing.", UNIT(s)->id);
3279                         service_unwatch_pid_file(s);
3280                         if (s->state == SERVICE_START)
3281                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3282                         else
3283                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3284                 }
3285                 break;
3286
3287         case SERVICE_RUNNING:
3288                 /* service_enter_running() will figure out what to do */
3289                 service_enter_running(s, SERVICE_SUCCESS);
3290                 break;
3291
3292         case SERVICE_STOP_SIGTERM:
3293         case SERVICE_STOP_SIGKILL:
3294
3295                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3296                         service_enter_stop_post(s, SERVICE_SUCCESS);
3297
3298                 break;
3299
3300         case SERVICE_STOP_POST:
3301         case SERVICE_FINAL_SIGTERM:
3302         case SERVICE_FINAL_SIGKILL:
3303                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3304                         service_enter_dead(s, SERVICE_SUCCESS, true);
3305
3306                 break;
3307
3308         default:
3309                 ;
3310         }
3311 }
3312
3313 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3314         Service *s = SERVICE(u);
3315         const char *e;
3316         bool notify_dbus = false;
3317
3318         assert(u);
3319
3320         log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
3321                        u->id, pid, tags && *tags ? tags[0] : "(empty)");
3322
3323         if (s->notify_access == NOTIFY_NONE) {
3324                 log_warning_unit(u->id,
3325                                  "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
3326                                  u->id, pid);
3327                 return;
3328         }
3329
3330         if (s->notify_access == NOTIFY_MAIN && s->main_pid != 0 && pid != s->main_pid) {
3331                 log_warning_unit(u->id,
3332                                  "%s: Got notification message from PID "PID_FMT", but reception only permitted for PID "PID_FMT,
3333                                  u->id, pid, s->main_pid);
3334                 return;
3335         }
3336
3337         /* Interpret MAINPID= */
3338         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3339             (s->state == SERVICE_START ||
3340              s->state == SERVICE_START_POST ||
3341              s->state == SERVICE_RUNNING ||
3342              s->state == SERVICE_RELOAD)) {
3343
3344                 if (parse_pid(e + 8, &pid) < 0)
3345                         log_warning_unit(u->id, "Failed to parse notification message %s", e);
3346                 else {
3347                         log_debug_unit(u->id, "%s: got %s", u->id, e);
3348                         service_set_main_pid(s, pid);
3349                         unit_watch_pid(UNIT(s), pid);
3350                         notify_dbus = true;
3351                 }
3352         }
3353
3354         /* Interpret READY= */
3355         if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
3356                 log_debug_unit(u->id, "%s: got READY=1", u->id);
3357                 service_enter_start_post(s);
3358                 notify_dbus = true;
3359         }
3360
3361         /* Interpret STATUS= */
3362         e = strv_find_prefix(tags, "STATUS=");
3363         if (e) {
3364                 char *t;
3365
3366                 if (e[7]) {
3367                         if (!utf8_is_valid(e+7)) {
3368                                 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
3369                                 return;
3370                         }
3371
3372                         log_debug_unit(u->id, "%s: got %s", u->id, e);
3373
3374                         t = strdup(e+7);
3375                         if (!t) {
3376                                 log_oom();
3377                                 return;
3378                         }
3379
3380                 } else
3381                         t = NULL;
3382
3383                 if (!streq_ptr(s->status_text, t)) {
3384                         free(s->status_text);
3385                         s->status_text = t;
3386                         notify_dbus = true;
3387                 } else
3388                         free(t);
3389         }
3390
3391         /* Interpet WATCHDOG= */
3392         if (strv_find(tags, "WATCHDOG=1")) {
3393                 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
3394                 service_reset_watchdog(s);
3395         }
3396
3397         /* Notify clients about changed status or main pid */
3398         if (notify_dbus)
3399                 unit_add_to_dbus_queue(u);
3400 }
3401
3402 static int service_get_timeout(Unit *u, uint64_t *timeout) {
3403         Service *s = SERVICE(u);
3404         int r;
3405
3406         if (!s->timer_event_source)
3407                 return 0;
3408
3409         r = sd_event_source_get_time(s->timer_event_source, timeout);
3410         if (r < 0)
3411                 return r;
3412
3413         return 1;
3414 }
3415
3416 #ifdef HAVE_SYSV_COMPAT
3417
3418 static int service_enumerate(Manager *m) {
3419         char **p;
3420         unsigned i;
3421         _cleanup_closedir_ DIR *d = NULL;
3422         _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3423         Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3424         _cleanup_set_free_ Set *shutdown_services = NULL;
3425         Unit *service;
3426         Iterator j;
3427         int r;
3428
3429         assert(m);
3430
3431         if (m->running_as != SYSTEMD_SYSTEM)
3432                 return 0;
3433
3434         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3435                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3436                         struct dirent *de;
3437
3438                         free(path);
3439                         path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3440                         if (!path) {
3441                                 r = -ENOMEM;
3442                                 goto finish;
3443                         }
3444
3445                         if (d)
3446                                 closedir(d);
3447
3448                         d = opendir(path);
3449                         if (!d) {
3450                                 if (errno != ENOENT)
3451                                         log_warning("opendir(%s) failed: %m", path);
3452
3453                                 continue;
3454                         }
3455
3456                         while ((de = readdir(d))) {
3457                                 int a, b;
3458
3459                                 if (ignore_file(de->d_name))
3460                                         continue;
3461
3462                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3463                                         continue;
3464
3465                                 if (strlen(de->d_name) < 4)
3466                                         continue;
3467
3468                                 a = undecchar(de->d_name[1]);
3469                                 b = undecchar(de->d_name[2]);
3470
3471                                 if (a < 0 || b < 0)
3472                                         continue;
3473
3474                                 free(fpath);
3475                                 fpath = strjoin(path, "/", de->d_name, NULL);
3476                                 if (!fpath) {
3477                                         r = -ENOMEM;
3478                                         goto finish;
3479                                 }
3480
3481                                 if (access(fpath, X_OK) < 0) {
3482
3483                                         if (errno != ENOENT)
3484                                                 log_warning("access() failed on %s: %m", fpath);
3485
3486                                         continue;
3487                                 }
3488
3489                                 free(name);
3490                                 name = sysv_translate_name(de->d_name + 3);
3491                                 if (!name) {
3492                                         r = log_oom();
3493                                         goto finish;
3494                                 }
3495
3496                                 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3497                                 if (r < 0) {
3498                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3499                                         continue;
3500                                 }
3501
3502                                 if (de->d_name[0] == 'S')  {
3503
3504                                         if (rcnd_table[i].type == RUNLEVEL_UP) {
3505                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3506                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3507
3508                                                 SERVICE(service)->sysv_enabled = true;
3509                                         }
3510
3511                                         r = set_ensure_allocated(&runlevel_services[i],
3512                                                                  trivial_hash_func, trivial_compare_func);
3513                                         if (r < 0)
3514                                                 goto finish;
3515
3516                                         r = set_put(runlevel_services[i], service);
3517                                         if (r < 0)
3518                                                 goto finish;
3519
3520                                 } else if (de->d_name[0] == 'K' &&
3521                                            (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3522
3523                                         r = set_ensure_allocated(&shutdown_services,
3524                                                                  trivial_hash_func, trivial_compare_func);
3525                                         if (r < 0)
3526                                                 goto finish;
3527
3528                                         r = set_put(shutdown_services, service);
3529                                         if (r < 0)
3530                                                 goto finish;
3531                                 }
3532                         }
3533                 }
3534
3535         /* Now we loaded all stubs and are aware of the lowest
3536         start-up priority for all services, not let's actually load
3537         the services, this will also tell us which services are
3538         actually native now */
3539         manager_dispatch_load_queue(m);
3540
3541         /* If this is a native service, rely on native ways to pull in
3542          * a service, don't pull it in via sysv rcN.d links. */
3543         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3544                 SET_FOREACH(service, runlevel_services[i], j) {
3545                         service = unit_follow_merge(service);
3546
3547                         if (service->fragment_path)
3548                                 continue;
3549
3550                         r = unit_add_two_dependencies_by_name_inverse(
3551                                 service, UNIT_AFTER, UNIT_WANTS,
3552                                 rcnd_table[i].target, NULL, true);
3553                         if (r < 0)
3554                                 goto finish;
3555                 }
3556
3557         /* We honour K links only for halt/reboot. For the normal
3558          * runlevels we assume the stop jobs will be implicitly added
3559          * by the core logic. Also, we don't really distinguish here
3560          * between the runlevels 0 and 6 and just add them to the
3561          * special shutdown target. */
3562         SET_FOREACH(service, shutdown_services, j) {
3563                 service = unit_follow_merge(service);
3564
3565                 if (service->fragment_path)
3566                         continue;
3567
3568                 r = unit_add_two_dependencies_by_name(
3569                         service, UNIT_BEFORE, UNIT_CONFLICTS,
3570                         SPECIAL_SHUTDOWN_TARGET, NULL, true);
3571                 if (r < 0)
3572                         goto finish;
3573         }
3574
3575         r = 0;
3576
3577 finish:
3578
3579         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3580                 set_free(runlevel_services[i]);
3581
3582         return r;
3583 }
3584 #endif
3585
3586 static void service_bus_name_owner_change(
3587                 Unit *u,
3588                 const char *name,
3589                 const char *old_owner,
3590                 const char *new_owner) {
3591
3592         Service *s = SERVICE(u);
3593         int r;
3594
3595         assert(s);
3596         assert(name);
3597
3598         assert(streq(s->bus_name, name));
3599         assert(old_owner || new_owner);
3600
3601         if (old_owner && new_owner)
3602                 log_debug_unit(u->id,
3603                                "%s's D-Bus name %s changed owner from %s to %s",
3604                                u->id, name, old_owner, new_owner);
3605         else if (old_owner)
3606                 log_debug_unit(u->id,
3607                                "%s's D-Bus name %s no longer registered by %s",
3608                                u->id, name, old_owner);
3609         else
3610                 log_debug_unit(u->id,
3611                                "%s's D-Bus name %s now registered by %s",
3612                                u->id, name, new_owner);
3613
3614         s->bus_name_good = !!new_owner;
3615
3616         if (s->type == SERVICE_DBUS) {
3617
3618                 /* service_enter_running() will figure out what to
3619                  * do */
3620                 if (s->state == SERVICE_RUNNING)
3621                         service_enter_running(s, SERVICE_SUCCESS);
3622                 else if (s->state == SERVICE_START && new_owner)
3623                         service_enter_start_post(s);
3624
3625         } else if (new_owner &&
3626                    s->main_pid <= 0 &&
3627                    (s->state == SERVICE_START ||
3628                     s->state == SERVICE_START_POST ||
3629                     s->state == SERVICE_RUNNING ||
3630                     s->state == SERVICE_RELOAD)) {
3631
3632                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
3633                 pid_t pid;
3634
3635                 /* Try to acquire PID from bus service */
3636
3637                 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3638                 if (r >= 0)
3639                         r = sd_bus_creds_get_pid(creds, &pid);
3640                 if (r >= 0) {
3641                         log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3642
3643                         service_set_main_pid(s, pid);
3644                         unit_watch_pid(UNIT(s), pid);
3645                 }
3646         }
3647 }
3648
3649 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3650         _cleanup_free_ char *peer = NULL;
3651         int r;
3652
3653         assert(s);
3654         assert(fd >= 0);
3655
3656         /* This is called by the socket code when instantiating a new
3657          * service for a stream socket and the socket needs to be
3658          * configured. */
3659
3660         if (UNIT(s)->load_state != UNIT_LOADED)
3661                 return -EINVAL;
3662
3663         if (s->socket_fd >= 0)
3664                 return -EBUSY;
3665
3666         if (s->state != SERVICE_DEAD)
3667                 return -EAGAIN;
3668
3669         if (getpeername_pretty(fd, &peer) >= 0) {
3670
3671                 if (UNIT(s)->description) {
3672                         _cleanup_free_ char *a;
3673
3674                         a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3675                         if (!a)
3676                                 return -ENOMEM;
3677
3678                         r = unit_set_description(UNIT(s), a);
3679                 }  else
3680                         r = unit_set_description(UNIT(s), peer);
3681
3682                 if (r < 0)
3683                         return r;
3684         }
3685
3686         s->socket_fd = fd;
3687
3688         unit_ref_set(&s->accept_socket, UNIT(sock));
3689
3690         return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3691 }
3692
3693 static void service_reset_failed(Unit *u) {
3694         Service *s = SERVICE(u);
3695
3696         assert(s);
3697
3698         if (s->state == SERVICE_FAILED)
3699                 service_set_state(s, SERVICE_DEAD);
3700
3701         s->result = SERVICE_SUCCESS;
3702         s->reload_result = SERVICE_SUCCESS;
3703
3704         RATELIMIT_RESET(s->start_limit);
3705 }
3706
3707 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3708         Service *s = SERVICE(u);
3709
3710         return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3711 }
3712
3713 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3714         [SERVICE_DEAD] = "dead",
3715         [SERVICE_START_PRE] = "start-pre",
3716         [SERVICE_START] = "start",
3717         [SERVICE_START_POST] = "start-post",
3718         [SERVICE_RUNNING] = "running",
3719         [SERVICE_EXITED] = "exited",
3720         [SERVICE_RELOAD] = "reload",
3721         [SERVICE_STOP] = "stop",
3722         [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3723         [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3724         [SERVICE_STOP_POST] = "stop-post",
3725         [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3726         [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3727         [SERVICE_FAILED] = "failed",
3728         [SERVICE_AUTO_RESTART] = "auto-restart",
3729 };
3730
3731 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3732
3733 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3734         [SERVICE_RESTART_NO] = "no",
3735         [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3736         [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3737         [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3738         [SERVICE_RESTART_ON_ABORT] = "on-abort",
3739         [SERVICE_RESTART_ALWAYS] = "always"
3740 };
3741
3742 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3743
3744 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3745         [SERVICE_SIMPLE] = "simple",
3746         [SERVICE_FORKING] = "forking",
3747         [SERVICE_ONESHOT] = "oneshot",
3748         [SERVICE_DBUS] = "dbus",
3749         [SERVICE_NOTIFY] = "notify",
3750         [SERVICE_IDLE] = "idle"
3751 };
3752
3753 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3754
3755 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3756         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3757         [SERVICE_EXEC_START] = "ExecStart",
3758         [SERVICE_EXEC_START_POST] = "ExecStartPost",
3759         [SERVICE_EXEC_RELOAD] = "ExecReload",
3760         [SERVICE_EXEC_STOP] = "ExecStop",
3761         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3762 };
3763
3764 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3765
3766 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3767         [NOTIFY_NONE] = "none",
3768         [NOTIFY_MAIN] = "main",
3769         [NOTIFY_ALL] = "all"
3770 };
3771
3772 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3773
3774 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3775         [SERVICE_SUCCESS] = "success",
3776         [SERVICE_FAILURE_RESOURCES] = "resources",
3777         [SERVICE_FAILURE_TIMEOUT] = "timeout",
3778         [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3779         [SERVICE_FAILURE_SIGNAL] = "signal",
3780         [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3781         [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3782         [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3783 };
3784
3785 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3786
3787 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3788         [SERVICE_START_LIMIT_NONE] = "none",
3789         [SERVICE_START_LIMIT_REBOOT] = "reboot",
3790         [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3791         [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3792 };
3793 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3794
3795 const UnitVTable service_vtable = {
3796         .object_size = sizeof(Service),
3797         .exec_context_offset = offsetof(Service, exec_context),
3798         .cgroup_context_offset = offsetof(Service, cgroup_context),
3799         .kill_context_offset = offsetof(Service, kill_context),
3800         .exec_runtime_offset = offsetof(Service, exec_runtime),
3801
3802         .sections =
3803                 "Unit\0"
3804                 "Service\0"
3805                 "Install\0",
3806         .private_section = "Service",
3807
3808         .init = service_init,
3809         .done = service_done,
3810         .load = service_load,
3811
3812         .coldplug = service_coldplug,
3813
3814         .dump = service_dump,
3815
3816         .start = service_start,
3817         .stop = service_stop,
3818         .reload = service_reload,
3819
3820         .can_reload = service_can_reload,
3821
3822         .kill = service_kill,
3823
3824         .serialize = service_serialize,
3825         .deserialize_item = service_deserialize_item,
3826
3827         .active_state = service_active_state,
3828         .sub_state_to_string = service_sub_state_to_string,
3829
3830         .check_gc = service_check_gc,
3831         .check_snapshot = service_check_snapshot,
3832
3833         .sigchld_event = service_sigchld_event,
3834
3835         .reset_failed = service_reset_failed,
3836
3837         .notify_cgroup_empty = service_notify_cgroup_empty_event,
3838         .notify_message = service_notify_message,
3839
3840         .bus_name_owner_change = service_bus_name_owner_change,
3841
3842         .bus_interface = "org.freedesktop.systemd1.Service",
3843         .bus_vtable = bus_service_vtable,
3844         .bus_set_property = bus_service_set_property,
3845         .bus_commit_properties = bus_service_commit_properties,
3846
3847         .get_timeout = service_get_timeout,
3848
3849 #ifdef HAVE_SYSV_COMPAT
3850         .enumerate = service_enumerate,
3851 #endif
3852
3853         .can_transient = true,
3854
3855         .status_message_formats = {
3856                 .starting_stopping = {
3857                         [0] = "Starting %s...",
3858                         [1] = "Stopping %s...",
3859                 },
3860                 .finished_start_job = {
3861                         [JOB_DONE]       = "Started %s.",
3862                         [JOB_FAILED]     = "Failed to start %s.",
3863                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
3864                         [JOB_TIMEOUT]    = "Timed out starting %s.",
3865                 },
3866                 .finished_stop_job = {
3867                         [JOB_DONE]       = "Stopped %s.",
3868                         [JOB_FAILED]     = "Stopped (with error) %s.",
3869                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
3870                 },
3871         },
3872 };