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