src/core/swap.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 <limits.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <sys/epoll.h>
  27 #include <sys/stat.h>
  28 #include <sys/swap.h>
  29 #include <libudev.h>
  30
  31 #include "unit.h"
  32 #include "swap.h"
  33 #include "load-fragment.h"
  34 #include "load-dropin.h"
  35 #include "unit-name.h"
  36 #include "dbus-swap.h"
  37 #include "special.h"
  38 #include "bus-errors.h"
  39 #include "exit-status.h"
  40 #include "def.h"
  41 #include "path-util.h"
  42 #include "virt.h"
  43
  44 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
  45         [SWAP_DEAD] = UNIT_INACTIVE,
  46         [SWAP_ACTIVATING] = UNIT_ACTIVATING,
  47         [SWAP_ACTIVE] = UNIT_ACTIVE,
  48         [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
  49         [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
  50         [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
  51         [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
  52         [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
  53         [SWAP_FAILED] = UNIT_FAILED
  54 };
  55
  56 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  57 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  58
  59 static void swap_unset_proc_swaps(Swap *s) {
  60         Swap *first;
  61         Hashmap *swaps;
  62
  63         assert(s);
  64
  65         if (!s->parameters_proc_swaps.what)
  66                 return;
  67
  68         /* Remove this unit from the chain of swaps which share the
  69          * same kernel swap device. */
  70         swaps = UNIT(s)->manager->swaps_by_proc_swaps;
  71         first = hashmap_get(swaps, s->parameters_proc_swaps.what);
  72         LIST_REMOVE(same_proc_swaps, first, s);
  73
  74         if (first)
  75                 hashmap_remove_and_replace(swaps,
  76                                            s->parameters_proc_swaps.what,
  77                                            first->parameters_proc_swaps.what,
  78                                            first);
  79         else
  80                 hashmap_remove(swaps, s->parameters_proc_swaps.what);
  81
  82         free(s->parameters_proc_swaps.what);
  83         s->parameters_proc_swaps.what = NULL;
  84 }
  85
  86 static void swap_init(Unit *u) {
  87         Swap *s = SWAP(u);
  88
  89         assert(s);
  90         assert(UNIT(s)->load_state == UNIT_STUB);
  91
  92         s->timeout_usec = u->manager->default_timeout_start_usec;
  93
  94         exec_context_init(&s->exec_context);
  95         s->exec_context.std_output = u->manager->default_std_output;
  96         s->exec_context.std_error = u->manager->default_std_error;
  97         kill_context_init(&s->kill_context);
  98         cgroup_context_init(&s->cgroup_context);
  99
 100         s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
 101
 102         s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 103
 104         UNIT(s)->ignore_on_isolate = true;
 105 }
 106
 107 static void swap_unwatch_control_pid(Swap *s) {
 108         assert(s);
 109
 110         if (s->control_pid <= 0)
 111                 return;
 112
 113         unit_unwatch_pid(UNIT(s), s->control_pid);
 114         s->control_pid = 0;
 115 }
 116
 117 static void swap_done(Unit *u) {
 118         Swap *s = SWAP(u);
 119
 120         assert(s);
 121
 122         swap_unset_proc_swaps(s);
 123
 124         free(s->what);
 125         s->what = NULL;
 126
 127         free(s->parameters_fragment.what);
 128         s->parameters_fragment.what = NULL;
 129
 130         exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
 131         exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
 132         s->control_command = NULL;
 133
 134         cgroup_context_done(&s->cgroup_context);
 135
 136         swap_unwatch_control_pid(s);
 137
 138         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 139 }
 140
 141 static int swap_arm_timer(Swap *s) {
 142         int r;
 143
 144         assert(s);
 145
 146         if (s->timeout_usec <= 0) {
 147                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 148                 return 0;
 149         }
 150
 151         if (s->timer_event_source) {
 152                 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
 153                 if (r < 0)
 154                         return r;
 155
 156                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 157         }
 158
 159         return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, swap_dispatch_timer, s, &s->timer_event_source);
 160 }
 161
 162 static int swap_add_device_links(Swap *s) {
 163         SwapParameters *p;
 164
 165         assert(s);
 166
 167         if (!s->what)
 168                 return 0;
 169
 170         if (s->from_fragment)
 171                 p = &s->parameters_fragment;
 172         else
 173                 return 0;
 174
 175         if (is_device_path(s->what))
 176                 return unit_add_node_link(UNIT(s), s->what, !p->noauto &&
 177                                           UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
 178         else
 179                 /* File based swap devices need to be ordered after
 180                  * systemd-remount-fs.service, since they might need a
 181                  * writable file system. */
 182                 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
 183 }
 184
 185 static int swap_add_default_dependencies(Swap *s) {
 186         bool nofail = false, noauto = false;
 187         int r;
 188
 189         assert(s);
 190
 191         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
 192                 return 0;
 193
 194         if (detect_container(NULL) > 0)
 195                 return 0;
 196
 197         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 198         if (r < 0)
 199                 return r;
 200
 201         if (s->from_fragment) {
 202                 SwapParameters *p = &s->parameters_fragment;
 203
 204                 nofail = p->nofail;
 205                 noauto = p->noauto;
 206         }
 207
 208         if (!noauto) {
 209                 if (nofail)
 210                         r = unit_add_dependency_by_name_inverse(UNIT(s),
 211                                 UNIT_WANTS, SPECIAL_SWAP_TARGET, NULL, true);
 212                 else
 213                         r = unit_add_two_dependencies_by_name_inverse(UNIT(s),
 214                                 UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SWAP_TARGET, NULL, true);
 215                 if (r < 0)
 216                         return r;
 217         }
 218
 219         return 0;
 220 }
 221
 222 static int swap_verify(Swap *s) {
 223         bool b;
 224         _cleanup_free_ char *e = NULL;
 225
 226         if (UNIT(s)->load_state != UNIT_LOADED)
 227                   return 0;
 228
 229         e = unit_name_from_path(s->what, ".swap");
 230         if (e == NULL)
 231                 return log_oom();
 232
 233         b = unit_has_name(UNIT(s), e);
 234         if (!b) {
 235                 log_error_unit(UNIT(s)->id,
 236                                "%s: Value of \"What\" and unit name do not match, not loading.",
 237                                UNIT(s)->id);
 238                 return -EINVAL;
 239         }
 240
 241         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 242                 log_error_unit(UNIT(s)->id,
 243                                "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.",
 244                                UNIT(s)->id);
 245                 return -EINVAL;
 246         }
 247
 248         return 0;
 249 }
 250
 251 static int swap_load(Unit *u) {
 252         int r;
 253         Swap *s = SWAP(u);
 254
 255         assert(s);
 256         assert(u->load_state == UNIT_STUB);
 257
 258         /* Load a .swap file */
 259         r = unit_load_fragment_and_dropin_optional(u);
 260         if (r < 0)
 261                 return r;
 262
 263         if (u->load_state == UNIT_LOADED) {
 264                 r = unit_add_exec_dependencies(u, &s->exec_context);
 265                 if (r < 0)
 266                         return r;
 267
 268                 if (UNIT(s)->fragment_path)
 269                         s->from_fragment = true;
 270
 271                 if (!s->what) {
 272                         if (s->parameters_fragment.what)
 273                                 s->what = strdup(s->parameters_fragment.what);
 274                         else if (s->parameters_proc_swaps.what)
 275                                 s->what = strdup(s->parameters_proc_swaps.what);
 276                         else
 277                                 s->what = unit_name_to_path(u->id);
 278
 279                         if (!s->what)
 280                                 return -ENOMEM;
 281                 }
 282
 283                 path_kill_slashes(s->what);
 284
 285                 if (!UNIT(s)->description)
 286                         if ((r = unit_set_description(u, s->what)) < 0)
 287                                 return r;
 288
 289                 r = unit_require_mounts_for(UNIT(s), s->what);
 290                 if (r < 0)
 291                         return r;
 292
 293                 r = swap_add_device_links(s);
 294                 if (r < 0)
 295                         return r;
 296
 297                 r = unit_add_default_slice(u);
 298                 if (r < 0)
 299                         return r;
 300
 301                 if (UNIT(s)->default_dependencies) {
 302                         r = swap_add_default_dependencies(s);
 303                         if (r < 0)
 304                                 return r;
 305                 }
 306
 307                 r = unit_exec_context_defaults(u, &s->exec_context);
 308                 if (r < 0)
 309                         return r;
 310         }
 311
 312         return swap_verify(s);
 313 }
 314
 315 static int swap_add_one(
 316                 Manager *m,
 317                 const char *what,
 318                 const char *what_proc_swaps,
 319                 int priority,
 320                 bool noauto,
 321                 bool nofail,
 322                 bool set_flags) {
 323
 324         Unit *u = NULL;
 325         _cleanup_free_ char *e = NULL;
 326         char *wp = NULL;
 327         bool delete = false;
 328         int r;
 329         SwapParameters *p;
 330         Swap *first;
 331
 332         assert(m);
 333         assert(what);
 334         assert(what_proc_swaps);
 335
 336         e = unit_name_from_path(what, ".swap");
 337         if (!e)
 338                 return log_oom();
 339
 340         u = manager_get_unit(m, e);
 341
 342         if (u &&
 343             SWAP(u)->from_proc_swaps &&
 344             !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
 345                 return -EEXIST;
 346
 347         if (!u) {
 348                 delete = true;
 349
 350                 u = unit_new(m, sizeof(Swap));
 351                 if (!u)
 352                         return log_oom();
 353
 354                 r = unit_add_name(u, e);
 355                 if (r < 0)
 356                         goto fail;
 357
 358                 SWAP(u)->what = strdup(what);
 359                 if (!SWAP(u)->what) {
 360                         r = log_oom();
 361                         goto fail;
 362                 }
 363
 364                 unit_add_to_load_queue(u);
 365         } else
 366                 delete = false;
 367
 368         p = &SWAP(u)->parameters_proc_swaps;
 369
 370         if (!p->what) {
 371                 wp = strdup(what_proc_swaps);
 372                 if (!wp) {
 373                         r = log_oom();
 374                         goto fail;
 375                 }
 376
 377                 if (!m->swaps_by_proc_swaps) {
 378                         m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func);
 379                         if (!m->swaps_by_proc_swaps) {
 380                                 r = log_oom();
 381                                 goto fail;
 382                         }
 383                 }
 384
 385                 free(p->what);
 386                 p->what = wp;
 387
 388                 first = hashmap_get(m->swaps_by_proc_swaps, wp);
 389                 LIST_PREPEND(same_proc_swaps, first, SWAP(u));
 390
 391                 r = hashmap_replace(m->swaps_by_proc_swaps, wp, first);
 392                 if (r < 0)
 393                         goto fail;
 394         }
 395
 396         if (set_flags) {
 397                 SWAP(u)->is_active = true;
 398                 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
 399         }
 400
 401         SWAP(u)->from_proc_swaps = true;
 402
 403         p->priority = priority;
 404         p->noauto = noauto;
 405         p->nofail = nofail;
 406
 407         unit_add_to_dbus_queue(u);
 408
 409         return 0;
 410
 411 fail:
 412         log_warning_unit(e, "Failed to load swap unit: %s", strerror(-r));
 413
 414         free(wp);
 415
 416         if (delete && u)
 417                 unit_free(u);
 418
 419         return r;
 420 }
 421
 422 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
 423         struct stat st;
 424         int r = 0, k;
 425
 426         assert(m);
 427
 428         if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
 429                 struct udev_device *d;
 430                 const char *dn;
 431                 struct udev_list_entry *item = NULL, *first = NULL;
 432
 433                 /* So this is a proper swap device. Create swap units
 434                  * for all names this swap device is known under */
 435
 436                 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
 437                 if (!d)
 438                         return log_oom();
 439
 440                 dn = udev_device_get_devnode(d);
 441                 /* Skip dn==device, since that case will be handled below */
 442                 if (dn && !streq(dn, device))
 443                         r = swap_add_one(m, dn, device, prio, false, false, set_flags);
 444
 445                 /* Add additional units for all symlinks */
 446                 first = udev_device_get_devlinks_list_entry(d);
 447                 udev_list_entry_foreach(item, first) {
 448                         const char *p;
 449
 450                         /* Don't bother with the /dev/block links */
 451                         p = udev_list_entry_get_name(item);
 452
 453                         if (path_startswith(p, "/dev/block/"))
 454                                 continue;
 455
 456                         if (stat(p, &st) >= 0)
 457                                 if ((!S_ISBLK(st.st_mode)) ||
 458                                     st.st_rdev != udev_device_get_devnum(d))
 459                                         continue;
 460
 461                         k = swap_add_one(m, p, device, prio, false, false, set_flags);
 462                         if (k < 0)
 463                                 r = k;
 464                 }
 465
 466                 udev_device_unref(d);
 467         }
 468
 469         k = swap_add_one(m, device, device, prio, false, false, set_flags);
 470         if (k < 0)
 471                 r = k;
 472
 473         return r;
 474 }
 475
 476 static void swap_set_state(Swap *s, SwapState state) {
 477         SwapState old_state;
 478
 479         assert(s);
 480
 481         old_state = s->state;
 482         s->state = state;
 483
 484         if (state != SWAP_ACTIVATING &&
 485             state != SWAP_ACTIVATING_SIGTERM &&
 486             state != SWAP_ACTIVATING_SIGKILL &&
 487             state != SWAP_DEACTIVATING &&
 488             state != SWAP_DEACTIVATING_SIGTERM &&
 489             state != SWAP_DEACTIVATING_SIGKILL) {
 490                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 491                 swap_unwatch_control_pid(s);
 492                 s->control_command = NULL;
 493                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 494         }
 495
 496         if (state != old_state)
 497                 log_debug_unit(UNIT(s)->id,
 498                                "%s changed %s -> %s",
 499                                UNIT(s)->id,
 500                                swap_state_to_string(old_state),
 501                                swap_state_to_string(state));
 502
 503         unit_notify(UNIT(s), state_translation_table[old_state],
 504                     state_translation_table[state], true);
 505 }
 506
 507 static int swap_coldplug(Unit *u) {
 508         Swap *s = SWAP(u);
 509         SwapState new_state = SWAP_DEAD;
 510         int r;
 511
 512         assert(s);
 513         assert(s->state == SWAP_DEAD);
 514
 515         if (s->deserialized_state != s->state)
 516                 new_state = s->deserialized_state;
 517         else if (s->from_proc_swaps)
 518                 new_state = SWAP_ACTIVE;
 519
 520         if (new_state != s->state) {
 521
 522                 if (new_state == SWAP_ACTIVATING ||
 523                     new_state == SWAP_ACTIVATING_SIGTERM ||
 524                     new_state == SWAP_ACTIVATING_SIGKILL ||
 525                     new_state == SWAP_DEACTIVATING ||
 526                     new_state == SWAP_DEACTIVATING_SIGTERM ||
 527                     new_state == SWAP_DEACTIVATING_SIGKILL) {
 528
 529                         if (s->control_pid <= 0)
 530                                 return -EBADMSG;
 531
 532                         r = unit_watch_pid(UNIT(s), s->control_pid);
 533                         if (r < 0)
 534                                 return r;
 535
 536                         r = swap_arm_timer(s);
 537                         if (r < 0)
 538                                 return r;
 539                 }
 540
 541                 swap_set_state(s, new_state);
 542         }
 543
 544         return 0;
 545 }
 546
 547 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
 548         Swap *s = SWAP(u);
 549         SwapParameters *p;
 550
 551         assert(s);
 552         assert(f);
 553
 554         if (s->from_proc_swaps)
 555                 p = &s->parameters_proc_swaps;
 556         else if (s->from_fragment)
 557                 p = &s->parameters_fragment;
 558         else
 559                 p = NULL;
 560
 561         fprintf(f,
 562                 "%sSwap State: %s\n"
 563                 "%sResult: %s\n"
 564                 "%sWhat: %s\n"
 565                 "%sFrom /proc/swaps: %s\n"
 566                 "%sFrom fragment: %s\n",
 567                 prefix, swap_state_to_string(s->state),
 568                 prefix, swap_result_to_string(s->result),
 569                 prefix, s->what,
 570                 prefix, yes_no(s->from_proc_swaps),
 571                 prefix, yes_no(s->from_fragment));
 572
 573         if (p)
 574                 fprintf(f,
 575                         "%sPriority: %i\n"
 576                         "%sNoAuto: %s\n"
 577                         "%sNoFail: %s\n",
 578                         prefix, p->priority,
 579                         prefix, yes_no(p->noauto),
 580                         prefix, yes_no(p->nofail));
 581
 582         if (s->control_pid > 0)
 583                 fprintf(f,
 584                         "%sControl PID: %lu\n",
 585                         prefix, (unsigned long) s->control_pid);
 586
 587         exec_context_dump(&s->exec_context, f, prefix);
 588         kill_context_dump(&s->kill_context, f, prefix);
 589 }
 590
 591 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
 592         pid_t pid;
 593         int r;
 594
 595         assert(s);
 596         assert(c);
 597         assert(_pid);
 598
 599         unit_realize_cgroup(UNIT(s));
 600
 601         r = swap_arm_timer(s);
 602         if (r < 0)
 603                 goto fail;
 604
 605         r = exec_spawn(c,
 606                        NULL,
 607                        &s->exec_context,
 608                        NULL, 0,
 609                        UNIT(s)->manager->environment,
 610                        true,
 611                        true,
 612                        true,
 613                        UNIT(s)->manager->confirm_spawn,
 614                        UNIT(s)->manager->cgroup_supported,
 615                        UNIT(s)->cgroup_path,
 616                        UNIT(s)->id,
 617                        NULL,
 618                        &pid);
 619         if (r < 0)
 620                 goto fail;
 621
 622         r = unit_watch_pid(UNIT(s), pid);
 623         if (r < 0)
 624                 /* FIXME: we need to do something here */
 625                 goto fail;
 626
 627         *_pid = pid;
 628
 629         return 0;
 630
 631 fail:
 632         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 633
 634         return r;
 635 }
 636
 637 static void swap_enter_dead(Swap *s, SwapResult f) {
 638         assert(s);
 639
 640         if (f != SWAP_SUCCESS)
 641                 s->result = f;
 642
 643         exec_context_tmp_dirs_done(&s->exec_context);
 644         swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
 645 }
 646
 647 static void swap_enter_active(Swap *s, SwapResult f) {
 648         assert(s);
 649
 650         if (f != SWAP_SUCCESS)
 651                 s->result = f;
 652
 653         swap_set_state(s, SWAP_ACTIVE);
 654 }
 655
 656 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
 657         int r;
 658
 659         assert(s);
 660
 661         if (f != SWAP_SUCCESS)
 662                 s->result = f;
 663
 664         r = unit_kill_context(
 665                         UNIT(s),
 666                         &s->kill_context,
 667                         state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM,
 668                         -1,
 669                         s->control_pid,
 670                         false);
 671         if (r < 0)
 672                 goto fail;
 673
 674         if (r > 0) {
 675                 r = swap_arm_timer(s);
 676                 if (r < 0)
 677                         goto fail;
 678
 679                 swap_set_state(s, state);
 680         } else
 681                 swap_enter_dead(s, SWAP_SUCCESS);
 682
 683         return;
 684
 685 fail:
 686         log_warning_unit(UNIT(s)->id,
 687                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
 688
 689         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 690 }
 691
 692 static void swap_enter_activating(Swap *s) {
 693         int r, priority;
 694
 695         assert(s);
 696
 697         s->control_command_id = SWAP_EXEC_ACTIVATE;
 698         s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
 699
 700         if (s->from_fragment)
 701                 priority = s->parameters_fragment.priority;
 702         else
 703                 priority = -1;
 704
 705         if (priority >= 0) {
 706                 char p[LINE_MAX];
 707
 708                 snprintf(p, sizeof(p), "%i", priority);
 709                 char_array_0(p);
 710
 711                 r = exec_command_set(
 712                                 s->control_command,
 713                                 "/sbin/swapon",
 714                                 "-p",
 715                                 p,
 716                                 s->what,
 717                                 NULL);
 718         } else
 719                 r = exec_command_set(
 720                                 s->control_command,
 721                                 "/sbin/swapon",
 722                                 s->what,
 723                                 NULL);
 724
 725         if (r < 0)
 726                 goto fail;
 727
 728         swap_unwatch_control_pid(s);
 729
 730         r = swap_spawn(s, s->control_command, &s->control_pid);
 731         if (r < 0)
 732                 goto fail;
 733
 734         swap_set_state(s, SWAP_ACTIVATING);
 735
 736         return;
 737
 738 fail:
 739         log_warning_unit(UNIT(s)->id,
 740                          "%s failed to run 'swapon' task: %s",
 741                          UNIT(s)->id, strerror(-r));
 742         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 743 }
 744
 745 static void swap_enter_deactivating(Swap *s) {
 746         int r;
 747
 748         assert(s);
 749
 750         s->control_command_id = SWAP_EXEC_DEACTIVATE;
 751         s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
 752
 753         r = exec_command_set(s->control_command,
 754                              "/sbin/swapoff",
 755                              s->what,
 756                              NULL);
 757         if (r < 0)
 758                 goto fail;
 759
 760         swap_unwatch_control_pid(s);
 761
 762         r = swap_spawn(s, s->control_command, &s->control_pid);
 763         if (r < 0)
 764                 goto fail;
 765
 766         swap_set_state(s, SWAP_DEACTIVATING);
 767
 768         return;
 769
 770 fail:
 771         log_warning_unit(UNIT(s)->id,
 772                          "%s failed to run 'swapoff' task: %s",
 773                          UNIT(s)->id, strerror(-r));
 774         swap_enter_active(s, SWAP_FAILURE_RESOURCES);
 775 }
 776
 777 static int swap_start(Unit *u) {
 778         Swap *s = SWAP(u);
 779
 780         assert(s);
 781
 782         /* We cannot fulfill this request right now, try again later
 783          * please! */
 784
 785         if (s->state == SWAP_DEACTIVATING ||
 786             s->state == SWAP_DEACTIVATING_SIGTERM ||
 787             s->state == SWAP_DEACTIVATING_SIGKILL ||
 788             s->state == SWAP_ACTIVATING_SIGTERM ||
 789             s->state == SWAP_ACTIVATING_SIGKILL)
 790                 return -EAGAIN;
 791
 792         if (s->state == SWAP_ACTIVATING)
 793                 return 0;
 794
 795         assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
 796
 797         if (detect_container(NULL) > 0)
 798                 return -EPERM;
 799
 800         s->result = SWAP_SUCCESS;
 801         swap_enter_activating(s);
 802         return 0;
 803 }
 804
 805 static int swap_stop(Unit *u) {
 806         Swap *s = SWAP(u);
 807
 808         assert(s);
 809
 810         if (s->state == SWAP_DEACTIVATING ||
 811             s->state == SWAP_DEACTIVATING_SIGTERM ||
 812             s->state == SWAP_DEACTIVATING_SIGKILL ||
 813             s->state == SWAP_ACTIVATING_SIGTERM ||
 814             s->state == SWAP_ACTIVATING_SIGKILL)
 815                 return 0;
 816
 817         assert(s->state == SWAP_ACTIVATING ||
 818                s->state == SWAP_ACTIVE);
 819
 820         if (detect_container(NULL) > 0)
 821                 return -EPERM;
 822
 823         swap_enter_deactivating(s);
 824         return 0;
 825 }
 826
 827 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
 828         Swap *s = SWAP(u);
 829
 830         assert(s);
 831         assert(f);
 832         assert(fds);
 833
 834         unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
 835         unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
 836
 837         if (s->control_pid > 0)
 838                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
 839
 840         if (s->control_command_id >= 0)
 841                 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
 842
 843         exec_context_serialize(&s->exec_context, UNIT(s), f);
 844
 845         return 0;
 846 }
 847
 848 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 849         Swap *s = SWAP(u);
 850
 851         assert(s);
 852         assert(fds);
 853
 854         if (streq(key, "state")) {
 855                 SwapState state;
 856
 857                 state = swap_state_from_string(value);
 858                 if (state < 0)
 859                         log_debug_unit(u->id, "Failed to parse state value %s", value);
 860                 else
 861                         s->deserialized_state = state;
 862         } else if (streq(key, "result")) {
 863                 SwapResult f;
 864
 865                 f = swap_result_from_string(value);
 866                 if (f < 0)
 867                         log_debug_unit(u->id, "Failed to parse result value %s", value);
 868                 else if (f != SWAP_SUCCESS)
 869                         s->result = f;
 870         } else if (streq(key, "control-pid")) {
 871                 pid_t pid;
 872
 873                 if (parse_pid(value, &pid) < 0)
 874                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
 875                 else
 876                         s->control_pid = pid;
 877
 878         } else if (streq(key, "control-command")) {
 879                 SwapExecCommand id;
 880
 881                 id = swap_exec_command_from_string(value);
 882                 if (id < 0)
 883                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
 884                 else {
 885                         s->control_command_id = id;
 886                         s->control_command = s->exec_command + id;
 887                 }
 888         } else if (streq(key, "tmp-dir")) {
 889                 char *t;
 890
 891                 t = strdup(value);
 892                 if (!t)
 893                         return log_oom();
 894
 895                 s->exec_context.tmp_dir = t;
 896         } else if (streq(key, "var-tmp-dir")) {
 897                 char *t;
 898
 899                 t = strdup(value);
 900                 if (!t)
 901                         return log_oom();
 902
 903                 s->exec_context.var_tmp_dir = t;
 904         } else
 905                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
 906
 907         return 0;
 908 }
 909
 910 _pure_ static UnitActiveState swap_active_state(Unit *u) {
 911         assert(u);
 912
 913         return state_translation_table[SWAP(u)->state];
 914 }
 915
 916 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
 917         assert(u);
 918
 919         return swap_state_to_string(SWAP(u)->state);
 920 }
 921
 922 _pure_ static bool swap_check_gc(Unit *u) {
 923         Swap *s = SWAP(u);
 924
 925         assert(s);
 926
 927         return s->from_proc_swaps;
 928 }
 929
 930 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 931         Swap *s = SWAP(u);
 932         SwapResult f;
 933
 934         assert(s);
 935         assert(pid >= 0);
 936
 937         if (pid != s->control_pid)
 938                 return;
 939
 940         s->control_pid = 0;
 941
 942         if (is_clean_exit(code, status, NULL))
 943                 f = SWAP_SUCCESS;
 944         else if (code == CLD_EXITED)
 945                 f = SWAP_FAILURE_EXIT_CODE;
 946         else if (code == CLD_KILLED)
 947                 f = SWAP_FAILURE_SIGNAL;
 948         else if (code == CLD_DUMPED)
 949                 f = SWAP_FAILURE_CORE_DUMP;
 950         else
 951                 assert_not_reached("Unknown code");
 952
 953         if (f != SWAP_SUCCESS)
 954                 s->result = f;
 955
 956         if (s->control_command) {
 957                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
 958
 959                 s->control_command = NULL;
 960                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 961         }
 962
 963         log_full_unit(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 964                       u->id,
 965                       "%s swap process exited, code=%s status=%i",
 966                       u->id, sigchld_code_to_string(code), status);
 967
 968         switch (s->state) {
 969
 970         case SWAP_ACTIVATING:
 971         case SWAP_ACTIVATING_SIGTERM:
 972         case SWAP_ACTIVATING_SIGKILL:
 973
 974                 if (f == SWAP_SUCCESS)
 975                         swap_enter_active(s, f);
 976                 else
 977                         swap_enter_dead(s, f);
 978                 break;
 979
 980         case SWAP_DEACTIVATING:
 981         case SWAP_DEACTIVATING_SIGKILL:
 982         case SWAP_DEACTIVATING_SIGTERM:
 983
 984                 if (f == SWAP_SUCCESS)
 985                         swap_enter_dead(s, f);
 986                 else
 987                         swap_enter_dead(s, f);
 988                 break;
 989
 990         default:
 991                 assert_not_reached("Uh, control process died at wrong time.");
 992         }
 993
 994         /* Notify clients about changed exit status */
 995         unit_add_to_dbus_queue(u);
 996
 997         /* Request a reload of /proc/swaps, so that following units
 998          * can follow our state change */
 999         u->manager->request_reload = true;
1000 }
1001
1002 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1003         Swap *s = SWAP(userdata);
1004
1005         assert(s);
1006         assert(s->timer_event_source == source);
1007
1008         switch (s->state) {
1009
1010         case SWAP_ACTIVATING:
1011                 log_warning_unit(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1012                 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1013                 break;
1014
1015         case SWAP_DEACTIVATING:
1016                 log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1017                 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1018                 break;
1019
1020         case SWAP_ACTIVATING_SIGTERM:
1021                 if (s->kill_context.send_sigkill) {
1022                         log_warning_unit(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1023                         swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1024                 } else {
1025                         log_warning_unit(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1026                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1027                 }
1028                 break;
1029
1030         case SWAP_DEACTIVATING_SIGTERM:
1031                 if (s->kill_context.send_sigkill) {
1032                         log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1033                         swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1034                 } else {
1035                         log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1036                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1037                 }
1038                 break;
1039
1040         case SWAP_ACTIVATING_SIGKILL:
1041         case SWAP_DEACTIVATING_SIGKILL:
1042                 log_warning_unit(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1043                 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1044                 break;
1045
1046         default:
1047                 assert_not_reached("Timeout at wrong time.");
1048         }
1049
1050         return 0;
1051 }
1052
1053 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1054         unsigned i;
1055         int r = 0;
1056
1057         assert(m);
1058
1059         rewind(m->proc_swaps);
1060
1061         (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1062
1063         for (i = 1;; i++) {
1064                 _cleanup_free_ char *dev = NULL, *d = NULL;
1065                 int prio = 0, k;
1066
1067                 k = fscanf(m->proc_swaps,
1068                            "%ms "  /* device/file */
1069                            "%*s "  /* type of swap */
1070                            "%*s "  /* swap size */
1071                            "%*s "  /* used */
1072                            "%i\n", /* priority */
1073                            &dev, &prio);
1074                 if (k != 2) {
1075                         if (k == EOF)
1076                                 break;
1077
1078                         log_warning("Failed to parse /proc/swaps:%u", i);
1079                         continue;
1080                 }
1081
1082                 d = cunescape(dev);
1083                 if (!d)
1084                         return -ENOMEM;
1085
1086                 k = swap_process_new_swap(m, d, prio, set_flags);
1087                 if (k < 0)
1088                         r = k;
1089         }
1090
1091         return r;
1092 }
1093
1094 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1095         Manager *m = userdata;
1096         Unit *u;
1097         int r;
1098
1099         assert(m);
1100         assert(revents & EPOLLPRI);
1101
1102         r = swap_load_proc_swaps(m, true);
1103         if (r < 0) {
1104                 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1105
1106                 /* Reset flags, just in case, for late calls */
1107                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1108                         Swap *swap = SWAP(u);
1109
1110                         swap->is_active = swap->just_activated = false;
1111                 }
1112
1113                 return 0;
1114         }
1115
1116         manager_dispatch_load_queue(m);
1117
1118         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1119                 Swap *swap = SWAP(u);
1120
1121                 if (!swap->is_active) {
1122                         /* This has just been deactivated */
1123
1124                         swap->from_proc_swaps = false;
1125                         swap_unset_proc_swaps(swap);
1126
1127                         switch (swap->state) {
1128
1129                         case SWAP_ACTIVE:
1130                                 swap_enter_dead(swap, SWAP_SUCCESS);
1131                                 break;
1132
1133                         default:
1134                                 swap_set_state(swap, swap->state);
1135                                 break;
1136                         }
1137
1138                 } else if (swap->just_activated) {
1139
1140                         /* New swap entry */
1141
1142                         switch (swap->state) {
1143
1144                         case SWAP_DEAD:
1145                         case SWAP_FAILED:
1146                                 swap_enter_active(swap, SWAP_SUCCESS);
1147                                 break;
1148
1149                         default:
1150                                 /* Nothing really changed, but let's
1151                                  * issue an notification call
1152                                  * nonetheless, in case somebody is
1153                                  * waiting for this. */
1154                                 swap_set_state(swap, swap->state);
1155                                 break;
1156                         }
1157                 }
1158
1159                 /* Reset the flags for later calls */
1160                 swap->is_active = swap->just_activated = false;
1161         }
1162
1163         return 1;
1164 }
1165
1166 static Unit *swap_following(Unit *u) {
1167         Swap *s = SWAP(u);
1168         Swap *other, *first = NULL;
1169
1170         assert(s);
1171
1172         if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1173                 return NULL;
1174
1175         /* Make everybody follow the unit that's named after the swap
1176          * device in the kernel */
1177
1178         LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1179                 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1180                         return UNIT(other);
1181
1182         LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1183                 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1184                         return UNIT(other);
1185
1186                 first = other;
1187         }
1188
1189         return UNIT(first);
1190 }
1191
1192 static int swap_following_set(Unit *u, Set **_set) {
1193         Swap *s = SWAP(u);
1194         Swap *other;
1195         Set *set;
1196         int r;
1197
1198         assert(s);
1199         assert(_set);
1200
1201         if (LIST_JUST_US(same_proc_swaps, s)) {
1202                 *_set = NULL;
1203                 return 0;
1204         }
1205
1206         if (!(set = set_new(NULL, NULL)))
1207                 return -ENOMEM;
1208
1209         LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1210                 if ((r = set_put(set, other)) < 0)
1211                         goto fail;
1212
1213         LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1214                 if ((r = set_put(set, other)) < 0)
1215                         goto fail;
1216
1217         *_set = set;
1218         return 1;
1219
1220 fail:
1221         set_free(set);
1222         return r;
1223 }
1224
1225 static void swap_shutdown(Manager *m) {
1226         assert(m);
1227
1228         m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1229
1230         if (m->proc_swaps) {
1231                 fclose(m->proc_swaps);
1232                 m->proc_swaps = NULL;
1233         }
1234
1235         hashmap_free(m->swaps_by_proc_swaps);
1236         m->swaps_by_proc_swaps = NULL;
1237 }
1238
1239 static int swap_enumerate(Manager *m) {
1240         int r;
1241         assert(m);
1242
1243         if (!m->proc_swaps) {
1244                 m->proc_swaps = fopen("/proc/swaps", "re");
1245                 if (!m->proc_swaps)
1246                         return errno == ENOENT ? 0 : -errno;
1247
1248                 r = sd_event_add_io(m->event, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m, &m->swap_event_source);
1249                 if (r < 0)
1250                         goto fail;
1251         }
1252
1253         r = swap_load_proc_swaps(m, false);
1254         if (r < 0)
1255                 goto fail;
1256
1257         return 0;
1258
1259 fail:
1260         swap_shutdown(m);
1261         return r;
1262 }
1263
1264 static void swap_reset_failed(Unit *u) {
1265         Swap *s = SWAP(u);
1266
1267         assert(s);
1268
1269         if (s->state == SWAP_FAILED)
1270                 swap_set_state(s, SWAP_DEAD);
1271
1272         s->result = SWAP_SUCCESS;
1273 }
1274
1275 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1276         return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1277 }
1278
1279 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1280         [SWAP_DEAD] = "dead",
1281         [SWAP_ACTIVATING] = "activating",
1282         [SWAP_ACTIVE] = "active",
1283         [SWAP_DEACTIVATING] = "deactivating",
1284         [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1285         [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1286         [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1287         [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1288         [SWAP_FAILED] = "failed"
1289 };
1290
1291 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1292
1293 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1294         [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1295         [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1296 };
1297
1298 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1299
1300 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1301         [SWAP_SUCCESS] = "success",
1302         [SWAP_FAILURE_RESOURCES] = "resources",
1303         [SWAP_FAILURE_TIMEOUT] = "timeout",
1304         [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1305         [SWAP_FAILURE_SIGNAL] = "signal",
1306         [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1307 };
1308
1309 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1310
1311 const UnitVTable swap_vtable = {
1312         .object_size = sizeof(Swap),
1313         .exec_context_offset = offsetof(Swap, exec_context),
1314         .cgroup_context_offset = offsetof(Swap, cgroup_context),
1315         .kill_context_offset = offsetof(Swap, kill_context),
1316
1317         .sections =
1318                 "Unit\0"
1319                 "Swap\0"
1320                 "Install\0",
1321         .private_section = "Swap",
1322
1323         .no_alias = true,
1324         .no_instances = true,
1325
1326         .init = swap_init,
1327         .load = swap_load,
1328         .done = swap_done,
1329
1330         .coldplug = swap_coldplug,
1331
1332         .dump = swap_dump,
1333
1334         .start = swap_start,
1335         .stop = swap_stop,
1336
1337         .kill = swap_kill,
1338
1339         .serialize = swap_serialize,
1340         .deserialize_item = swap_deserialize_item,
1341
1342         .active_state = swap_active_state,
1343         .sub_state_to_string = swap_sub_state_to_string,
1344
1345         .check_gc = swap_check_gc,
1346
1347         .sigchld_event = swap_sigchld_event,
1348
1349         .reset_failed = swap_reset_failed,
1350
1351         .bus_interface = "org.freedesktop.systemd1.Swap",
1352         .bus_vtable = bus_swap_vtable,
1353         .bus_changing_properties = bus_swap_changing_properties,
1354         .bus_set_property = bus_swap_set_property,
1355         .bus_commit_properties = bus_swap_commit_properties,
1356
1357         .following = swap_following,
1358         .following_set = swap_following_set,
1359
1360         .enumerate = swap_enumerate,
1361         .shutdown = swap_shutdown,
1362
1363         .status_message_formats = {
1364                 .starting_stopping = {
1365                         [0] = "Activating swap %s...",
1366                         [1] = "Deactivating swap %s...",
1367                 },
1368                 .finished_start_job = {
1369                         [JOB_DONE]       = "Activated swap %s.",
1370                         [JOB_FAILED]     = "Failed to activate swap %s.",
1371                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1372                         [JOB_TIMEOUT]    = "Timed out activating swap %s.",
1373                 },
1374                 .finished_stop_job = {
1375                         [JOB_DONE]       = "Deactivated swap %s.",
1376                         [JOB_FAILED]     = "Failed deactivating swap %s.",
1377                         [JOB_TIMEOUT]    = "Timed out deactivating swap %s.",
1378                 },
1379         },
1380 };