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