src/core/service.c

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