src/core/service.c

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