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