src/core/service.c

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