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