src/core/service.c

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