src/core/service.c

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