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