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