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