src/core/scope.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 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 <unistd.h>
  24
  25 #include "unit.h"
  26 #include "scope.h"
  27 #include "log.h"
  28 #include "dbus-scope.h"
  29 #include "special.h"
  30 #include "unit-name.h"
  31 #include "load-dropin.h"
  32
  33 static const UnitActiveState state_translation_table[_SCOPE_STATE_MAX] = {
  34         [SCOPE_DEAD] = UNIT_INACTIVE,
  35         [SCOPE_RUNNING] = UNIT_ACTIVE,
  36         [SCOPE_ABANDONED] = UNIT_ACTIVE,
  37         [SCOPE_STOP_SIGTERM] = UNIT_DEACTIVATING,
  38         [SCOPE_STOP_SIGKILL] = UNIT_DEACTIVATING,
  39         [SCOPE_FAILED] = UNIT_FAILED
  40 };
  41
  42 static int scope_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  43
  44 static void scope_init(Unit *u) {
  45         Scope *s = SCOPE(u);
  46
  47         assert(u);
  48         assert(u->load_state == UNIT_STUB);
  49
  50         s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
  51
  52         UNIT(s)->ignore_on_isolate = true;
  53         UNIT(s)->ignore_on_snapshot = true;
  54 }
  55
  56 static void scope_done(Unit *u) {
  57         Scope *s = SCOPE(u);
  58
  59         assert(u);
  60
  61         free(s->controller);
  62
  63         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
  64 }
  65
  66 static int scope_arm_timer(Scope *s) {
  67         int r;
  68
  69         assert(s);
  70
  71         if (s->timeout_stop_usec <= 0) {
  72                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
  73                 return 0;
  74         }
  75
  76         if (s->timer_event_source) {
  77                 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_stop_usec);
  78                 if (r < 0)
  79                         return r;
  80
  81                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
  82         }
  83
  84         return sd_event_add_time(
  85                         UNIT(s)->manager->event,
  86                         &s->timer_event_source,
  87                         CLOCK_MONOTONIC,
  88                         now(CLOCK_MONOTONIC) + s->timeout_stop_usec, 0,
  89                         scope_dispatch_timer, s);
  90 }
  91
  92 static void scope_set_state(Scope *s, ScopeState state) {
  93         ScopeState old_state;
  94         assert(s);
  95
  96         old_state = s->state;
  97         s->state = state;
  98
  99         if (!IN_SET(state, SCOPE_STOP_SIGTERM, SCOPE_STOP_SIGKILL))
 100                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 101
 102         if (IN_SET(state, SCOPE_DEAD, SCOPE_FAILED))
 103                 unit_unwatch_all_pids(UNIT(s));
 104
 105         if (state != old_state)
 106                 log_debug("%s changed %s -> %s", UNIT(s)->id, scope_state_to_string(old_state), scope_state_to_string(state));
 107
 108         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
 109 }
 110
 111 static int scope_add_default_dependencies(Scope *s) {
 112         int r;
 113
 114         assert(s);
 115
 116         /* Make sure scopes are unloaded on shutdown */
 117         r = unit_add_two_dependencies_by_name(
 118                         UNIT(s),
 119                         UNIT_BEFORE, UNIT_CONFLICTS,
 120                         SPECIAL_SHUTDOWN_TARGET, NULL, true);
 121         if (r < 0)
 122                 return r;
 123
 124         return 0;
 125 }
 126
 127 static int scope_verify(Scope *s) {
 128         assert(s);
 129
 130         if (UNIT(s)->load_state != UNIT_LOADED)
 131                 return 0;
 132
 133         if (set_isempty(UNIT(s)->pids) && UNIT(s)->manager->n_reloading <= 0) {
 134                 log_unit_error(UNIT(s)->id, "Scope %s has no PIDs. Refusing.", UNIT(s)->id);
 135                 return -EINVAL;
 136         }
 137
 138         return 0;
 139 }
 140
 141 static int scope_load(Unit *u) {
 142         Scope *s = SCOPE(u);
 143         int r;
 144
 145         assert(s);
 146         assert(u->load_state == UNIT_STUB);
 147
 148         if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
 149                 return -ENOENT;
 150
 151         u->load_state = UNIT_LOADED;
 152
 153         r = unit_load_dropin(u);
 154         if (r < 0)
 155                 return r;
 156
 157         r = unit_patch_contexts(u);
 158         if (r < 0)
 159                 return r;
 160
 161         r = unit_add_default_slice(u, &s->cgroup_context);
 162         if (r < 0)
 163                 return r;
 164
 165         if (u->default_dependencies) {
 166                 r = scope_add_default_dependencies(s);
 167                 if (r < 0)
 168                         return r;
 169         }
 170
 171         return scope_verify(s);
 172 }
 173
 174 static int scope_coldplug(Unit *u) {
 175         Scope *s = SCOPE(u);
 176         int r;
 177
 178         assert(s);
 179         assert(s->state == SCOPE_DEAD);
 180
 181         if (s->deserialized_state != s->state) {
 182
 183                 if (IN_SET(s->deserialized_state, SCOPE_STOP_SIGKILL, SCOPE_STOP_SIGTERM)) {
 184                         r = scope_arm_timer(s);
 185                         if (r < 0)
 186                                 return r;
 187                 }
 188
 189                 if (!IN_SET(s->deserialized_state, SCOPE_DEAD, SCOPE_FAILED))
 190                         unit_watch_all_pids(UNIT(s));
 191
 192                 scope_set_state(s, s->deserialized_state);
 193         }
 194
 195         return 0;
 196 }
 197
 198 static void scope_dump(Unit *u, FILE *f, const char *prefix) {
 199         Scope *s = SCOPE(u);
 200
 201         assert(s);
 202         assert(f);
 203
 204         fprintf(f,
 205                 "%sScope State: %s\n"
 206                 "%sResult: %s\n",
 207                 prefix, scope_state_to_string(s->state),
 208                 prefix, scope_result_to_string(s->result));
 209
 210         cgroup_context_dump(&s->cgroup_context, f, prefix);
 211         kill_context_dump(&s->kill_context, f, prefix);
 212 }
 213
 214 static void scope_enter_dead(Scope *s, ScopeResult f) {
 215         assert(s);
 216
 217         if (f != SCOPE_SUCCESS)
 218                 s->result = f;
 219
 220         scope_set_state(s, s->result != SCOPE_SUCCESS ? SCOPE_FAILED : SCOPE_DEAD);
 221 }
 222
 223 static void scope_enter_signal(Scope *s, ScopeState state, ScopeResult f) {
 224         bool skip_signal = false;
 225         int r;
 226
 227         assert(s);
 228
 229         if (f != SCOPE_SUCCESS)
 230                 s->result = f;
 231
 232         unit_watch_all_pids(UNIT(s));
 233
 234         /* If we have a controller set let's ask the controller nicely
 235          * to terminate the scope, instead of us going directly into
 236          * SIGTERM beserk mode */
 237         if (state == SCOPE_STOP_SIGTERM)
 238                 skip_signal = bus_scope_send_request_stop(s) > 0;
 239
 240         if (!skip_signal) {
 241                 r = unit_kill_context(
 242                                 UNIT(s),
 243                                 &s->kill_context,
 244                                 state != SCOPE_STOP_SIGTERM ? KILL_KILL : KILL_TERMINATE,
 245                                 -1, -1, false);
 246                 if (r < 0)
 247                         goto fail;
 248         } else
 249                 r = 1;
 250
 251         if (r > 0) {
 252                 r = scope_arm_timer(s);
 253                 if (r < 0)
 254                         goto fail;
 255
 256                 scope_set_state(s, state);
 257         } else if (state == SCOPE_STOP_SIGTERM)
 258                 scope_enter_signal(s, SCOPE_STOP_SIGKILL, SCOPE_SUCCESS);
 259         else
 260                 scope_enter_dead(s, SCOPE_SUCCESS);
 261
 262         return;
 263
 264 fail:
 265         log_unit_warning(UNIT(s)->id,
 266                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
 267
 268         scope_enter_dead(s, SCOPE_FAILURE_RESOURCES);
 269 }
 270
 271 static int scope_start(Unit *u) {
 272         Scope *s = SCOPE(u);
 273         int r;
 274
 275         assert(s);
 276
 277         if (s->state == SCOPE_FAILED)
 278                 return -EPERM;
 279
 280         if (s->state == SCOPE_STOP_SIGTERM ||
 281             s->state == SCOPE_STOP_SIGKILL)
 282                 return -EAGAIN;
 283
 284         assert(s->state == SCOPE_DEAD);
 285
 286         if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
 287                 return -ENOENT;
 288
 289         r = unit_attach_pids_to_cgroup(u);
 290         if (r < 0)
 291                 return r;
 292
 293         s->result = SCOPE_SUCCESS;
 294
 295         scope_set_state(s, SCOPE_RUNNING);
 296         return 1;
 297 }
 298
 299 static int scope_stop(Unit *u) {
 300         Scope *s = SCOPE(u);
 301
 302         assert(s);
 303
 304         if (s->state == SCOPE_STOP_SIGTERM ||
 305             s->state == SCOPE_STOP_SIGKILL)
 306                 return 0;
 307
 308         assert(s->state == SCOPE_RUNNING ||
 309                s->state == SCOPE_ABANDONED);
 310
 311         scope_enter_signal(s, SCOPE_STOP_SIGTERM, SCOPE_SUCCESS);
 312         return 1;
 313 }
 314
 315 static void scope_reset_failed(Unit *u) {
 316         Scope *s = SCOPE(u);
 317
 318         assert(s);
 319
 320         if (s->state == SCOPE_FAILED)
 321                 scope_set_state(s, SCOPE_DEAD);
 322
 323         s->result = SCOPE_SUCCESS;
 324 }
 325
 326 static int scope_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 327         return unit_kill_common(u, who, signo, -1, -1, error);
 328 }
 329
 330 static int scope_get_timeout(Unit *u, uint64_t *timeout) {
 331         Scope *s = SCOPE(u);
 332         int r;
 333
 334         if (!s->timer_event_source)
 335                 return 0;
 336
 337         r = sd_event_source_get_time(s->timer_event_source, timeout);
 338         if (r < 0)
 339                 return r;
 340
 341         return 1;
 342 }
 343
 344 static int scope_serialize(Unit *u, FILE *f, FDSet *fds) {
 345         Scope *s = SCOPE(u);
 346
 347         assert(s);
 348         assert(f);
 349         assert(fds);
 350
 351         unit_serialize_item(u, f, "state", scope_state_to_string(s->state));
 352         return 0;
 353 }
 354
 355 static int scope_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 356         Scope *s = SCOPE(u);
 357
 358         assert(u);
 359         assert(key);
 360         assert(value);
 361         assert(fds);
 362
 363         if (streq(key, "state")) {
 364                 ScopeState state;
 365
 366                 state = scope_state_from_string(value);
 367                 if (state < 0)
 368                         log_debug("Failed to parse state value %s", value);
 369                 else
 370                         s->deserialized_state = state;
 371
 372         } else
 373                 log_debug("Unknown serialization key '%s'", key);
 374
 375         return 0;
 376 }
 377
 378 static bool scope_check_gc(Unit *u) {
 379         assert(u);
 380
 381         /* Never clean up scopes that still have a process around,
 382          * even if the scope is formally dead. */
 383
 384         if (u->cgroup_path) {
 385                 int r;
 386
 387                 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
 388                 if (r <= 0)
 389                         return true;
 390         }
 391
 392         return false;
 393 }
 394
 395 static void scope_notify_cgroup_empty_event(Unit *u) {
 396         Scope *s = SCOPE(u);
 397         assert(u);
 398
 399         log_unit_debug(u->id, "%s: cgroup is empty", u->id);
 400
 401         if (IN_SET(s->state, SCOPE_RUNNING, SCOPE_ABANDONED, SCOPE_STOP_SIGTERM, SCOPE_STOP_SIGKILL))
 402                 scope_enter_dead(s, SCOPE_SUCCESS);
 403 }
 404
 405 static void scope_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 406
 407         /* If we get a SIGCHLD event for one of the processes we were
 408            interested in, then we look for others to watch, under the
 409            assumption that we'll sooner or later get a SIGCHLD for
 410            them, as the original process we watched was probably the
 411            parent of them, and they are hence now our children. */
 412
 413         unit_tidy_watch_pids(u, 0, 0);
 414         unit_watch_all_pids(u);
 415
 416         /* If the PID set is empty now, then let's finish this off */
 417         if (set_isempty(u->pids))
 418                 scope_notify_cgroup_empty_event(u);
 419 }
 420
 421 static int scope_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
 422         Scope *s = SCOPE(userdata);
 423
 424         assert(s);
 425         assert(s->timer_event_source == source);
 426
 427         switch (s->state) {
 428
 429         case SCOPE_STOP_SIGTERM:
 430                 if (s->kill_context.send_sigkill) {
 431                         log_unit_warning(UNIT(s)->id, "%s stopping timed out. Killing.", UNIT(s)->id);
 432                         scope_enter_signal(s, SCOPE_STOP_SIGKILL, SCOPE_FAILURE_TIMEOUT);
 433                 } else {
 434                         log_unit_warning(UNIT(s)->id, "%s stopping timed out. Skipping SIGKILL.", UNIT(s)->id);
 435                         scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
 436                 }
 437
 438                 break;
 439
 440         case SCOPE_STOP_SIGKILL:
 441                 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
 442                 scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
 443                 break;
 444
 445         default:
 446                 assert_not_reached("Timeout at wrong time.");
 447         }
 448
 449         return 0;
 450 }
 451
 452 int scope_abandon(Scope *s) {
 453         assert(s);
 454
 455         if (!IN_SET(s->state, SCOPE_RUNNING, SCOPE_ABANDONED))
 456                 return -ESTALE;
 457
 458         free(s->controller);
 459         s->controller = NULL;
 460
 461         /* The client is no longer watching the remaining processes,
 462          * so let's step in here, under the assumption that the
 463          * remaining processes will be sooner or later reassigned to
 464          * us as parent. */
 465
 466         unit_tidy_watch_pids(UNIT(s), 0, 0);
 467         unit_watch_all_pids(UNIT(s));
 468
 469         /* If the PID set is empty now, then let's finish this off */
 470         if (set_isempty(UNIT(s)->pids))
 471                 scope_notify_cgroup_empty_event(UNIT(s));
 472         else
 473                 scope_set_state(s, SCOPE_ABANDONED);
 474
 475         return 0;
 476 }
 477
 478 _pure_ static UnitActiveState scope_active_state(Unit *u) {
 479         assert(u);
 480
 481         return state_translation_table[SCOPE(u)->state];
 482 }
 483
 484 _pure_ static const char *scope_sub_state_to_string(Unit *u) {
 485         assert(u);
 486
 487         return scope_state_to_string(SCOPE(u)->state);
 488 }
 489
 490 static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
 491         [SCOPE_DEAD] = "dead",
 492         [SCOPE_RUNNING] = "running",
 493         [SCOPE_ABANDONED] = "abandoned",
 494         [SCOPE_STOP_SIGTERM] = "stop-sigterm",
 495         [SCOPE_STOP_SIGKILL] = "stop-sigkill",
 496         [SCOPE_FAILED] = "failed",
 497 };
 498
 499 DEFINE_STRING_TABLE_LOOKUP(scope_state, ScopeState);
 500
 501 static const char* const scope_result_table[_SCOPE_RESULT_MAX] = {
 502         [SCOPE_SUCCESS] = "success",
 503         [SCOPE_FAILURE_RESOURCES] = "resources",
 504         [SCOPE_FAILURE_TIMEOUT] = "timeout",
 505 };
 506
 507 DEFINE_STRING_TABLE_LOOKUP(scope_result, ScopeResult);
 508
 509 const UnitVTable scope_vtable = {
 510         .object_size = sizeof(Scope),
 511         .cgroup_context_offset = offsetof(Scope, cgroup_context),
 512         .kill_context_offset = offsetof(Scope, kill_context),
 513
 514         .sections =
 515                 "Unit\0"
 516                 "Scope\0"
 517                 "Install\0",
 518         .private_section = "Scope",
 519
 520         .no_alias = true,
 521         .no_instances = true,
 522
 523         .init = scope_init,
 524         .load = scope_load,
 525         .done = scope_done,
 526
 527         .coldplug = scope_coldplug,
 528
 529         .dump = scope_dump,
 530
 531         .start = scope_start,
 532         .stop = scope_stop,
 533
 534         .kill = scope_kill,
 535
 536         .get_timeout = scope_get_timeout,
 537
 538         .serialize = scope_serialize,
 539         .deserialize_item = scope_deserialize_item,
 540
 541         .active_state = scope_active_state,
 542         .sub_state_to_string = scope_sub_state_to_string,
 543
 544         .check_gc = scope_check_gc,
 545
 546         .sigchld_event = scope_sigchld_event,
 547
 548         .reset_failed = scope_reset_failed,
 549
 550         .notify_cgroup_empty = scope_notify_cgroup_empty_event,
 551
 552         .bus_interface = "org.freedesktop.systemd1.Scope",
 553         .bus_vtable = bus_scope_vtable,
 554         .bus_set_property = bus_scope_set_property,
 555         .bus_commit_properties = bus_scope_commit_properties,
 556
 557         .can_transient = true
 558 };