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) {
 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         unit_realize_cgroup(UNIT(s));
 608
 609         r = unit_setup_exec_runtime(UNIT(s));
 610         if (r < 0)
 611                 goto fail;
 612
 613         r = swap_arm_timer(s);
 614         if (r < 0)
 615                 goto fail;
 616
 617         exec_params.environment = UNIT(s)->manager->environment;
 618         exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
 619         exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
 620         exec_params.cgroup_path = UNIT(s)->cgroup_path;
 621         exec_params.cgroup_delegate = s->cgroup_context.delegate;
 622         exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
 623         exec_params.unit_id = UNIT(s)->id;
 624
 625         r = exec_spawn(c,
 626                        &s->exec_context,
 627                        &exec_params,
 628                        s->exec_runtime,
 629                        &pid);
 630         if (r < 0)
 631                 goto fail;
 632
 633         r = unit_watch_pid(UNIT(s), pid);
 634         if (r < 0)
 635                 /* FIXME: we need to do something here */
 636                 goto fail;
 637
 638         *_pid = pid;
 639
 640         return 0;
 641
 642 fail:
 643         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 644         return r;
 645 }
 646
 647 static void swap_enter_dead(Swap *s, SwapResult f) {
 648         assert(s);
 649
 650         if (f != SWAP_SUCCESS)
 651                 s->result = f;
 652
 653         exec_runtime_destroy(s->exec_runtime);
 654         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
 655
 656         exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
 657
 658         swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
 659 }
 660
 661 static void swap_enter_active(Swap *s, SwapResult f) {
 662         assert(s);
 663
 664         if (f != SWAP_SUCCESS)
 665                 s->result = f;
 666
 667         swap_set_state(s, SWAP_ACTIVE);
 668 }
 669
 670 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
 671         int r;
 672
 673         assert(s);
 674
 675         if (f != SWAP_SUCCESS)
 676                 s->result = f;
 677
 678         r = unit_kill_context(
 679                         UNIT(s),
 680                         &s->kill_context,
 681                         (state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM) ?
 682                         KILL_KILL : KILL_TERMINATE,
 683                         -1,
 684                         s->control_pid,
 685                         false);
 686         if (r < 0)
 687                 goto fail;
 688
 689         if (r > 0) {
 690                 r = swap_arm_timer(s);
 691                 if (r < 0)
 692                         goto fail;
 693
 694                 swap_set_state(s, state);
 695         } else if (state == SWAP_ACTIVATING_SIGTERM)
 696                 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_SUCCESS);
 697         else if (state == SWAP_DEACTIVATING_SIGTERM)
 698                 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
 699         else
 700                 swap_enter_dead(s, SWAP_SUCCESS);
 701
 702         return;
 703
 704 fail:
 705         log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
 706         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 707 }
 708
 709 static void swap_enter_activating(Swap *s) {
 710         _cleanup_free_ char *discard = NULL;
 711         int r, priority = -1;
 712
 713         assert(s);
 714
 715         s->control_command_id = SWAP_EXEC_ACTIVATE;
 716         s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
 717
 718         if (s->from_fragment) {
 719                 fstab_filter_options(s->parameters_fragment.options, "discard\0",
 720                                      NULL, &discard, NULL);
 721
 722                 priority = s->parameters_fragment.priority;
 723                 if (priority < 0)
 724                         fstab_find_pri(s->parameters_fragment.options, &priority);
 725         }
 726
 727         r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
 728         if (r < 0)
 729                 goto fail;
 730
 731         if (priority >= 0) {
 732                 char p[DECIMAL_STR_MAX(int)];
 733
 734                 sprintf(p, "%i", priority);
 735                 r = exec_command_append(s->control_command, "-p", p, NULL);
 736                 if (r < 0)
 737                         goto fail;
 738         }
 739
 740         if (discard && !streq(discard, "none")) {
 741                 const char *discard_arg;
 742
 743                 if (streq(discard, "all"))
 744                         discard_arg = "--discard";
 745                 else
 746                         discard_arg = strjoina("--discard=", discard);
 747
 748                 r = exec_command_append(s->control_command, discard_arg, NULL);
 749                 if (r < 0)
 750                         goto fail;
 751         }
 752
 753         r = exec_command_append(s->control_command, s->what, NULL);
 754         if (r < 0)
 755                 goto fail;
 756
 757         swap_unwatch_control_pid(s);
 758
 759         r = swap_spawn(s, s->control_command, &s->control_pid);
 760         if (r < 0)
 761                 goto fail;
 762
 763         swap_set_state(s, SWAP_ACTIVATING);
 764
 765         return;
 766
 767 fail:
 768         log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapon' task: %m", UNIT(s)->id);
 769         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 770 }
 771
 772 static void swap_enter_deactivating(Swap *s) {
 773         int r;
 774
 775         assert(s);
 776
 777         s->control_command_id = SWAP_EXEC_DEACTIVATE;
 778         s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
 779
 780         r = exec_command_set(s->control_command,
 781                              "/sbin/swapoff",
 782                              s->what,
 783                              NULL);
 784         if (r < 0)
 785                 goto fail;
 786
 787         swap_unwatch_control_pid(s);
 788
 789         r = swap_spawn(s, s->control_command, &s->control_pid);
 790         if (r < 0)
 791                 goto fail;
 792
 793         swap_set_state(s, SWAP_DEACTIVATING);
 794
 795         return;
 796
 797 fail:
 798         log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapoff' task: %m", UNIT(s)->id);
 799         swap_enter_active(s, SWAP_FAILURE_RESOURCES);
 800 }
 801
 802 static int swap_start(Unit *u) {
 803         Swap *s = SWAP(u), *other;
 804
 805         assert(s);
 806
 807         /* We cannot fulfill this request right now, try again later
 808          * please! */
 809
 810         if (s->state == SWAP_DEACTIVATING ||
 811             s->state == SWAP_DEACTIVATING_SIGTERM ||
 812             s->state == SWAP_DEACTIVATING_SIGKILL ||
 813             s->state == SWAP_ACTIVATING_SIGTERM ||
 814             s->state == SWAP_ACTIVATING_SIGKILL)
 815                 return -EAGAIN;
 816
 817         if (s->state == SWAP_ACTIVATING)
 818                 return 0;
 819
 820         assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
 821
 822         if (detect_container(NULL) > 0)
 823                 return -EPERM;
 824
 825         /* If there's a job for another swap unit for the same node
 826          * running, then let's not dispatch this one for now, and wait
 827          * until that other job has finished. */
 828         LIST_FOREACH_OTHERS(same_devnode, other, s)
 829                 if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING)
 830                         return -EAGAIN;
 831
 832         s->result = SWAP_SUCCESS;
 833         swap_enter_activating(s);
 834         return 1;
 835 }
 836
 837 static int swap_stop(Unit *u) {
 838         Swap *s = SWAP(u);
 839
 840         assert(s);
 841
 842         if (s->state == SWAP_DEACTIVATING ||
 843             s->state == SWAP_DEACTIVATING_SIGTERM ||
 844             s->state == SWAP_DEACTIVATING_SIGKILL ||
 845             s->state == SWAP_ACTIVATING_SIGTERM ||
 846             s->state == SWAP_ACTIVATING_SIGKILL)
 847                 return 0;
 848
 849         assert(s->state == SWAP_ACTIVATING ||
 850                s->state == SWAP_ACTIVATING_DONE ||
 851                s->state == SWAP_ACTIVE);
 852
 853         if (detect_container(NULL) > 0)
 854                 return -EPERM;
 855
 856         swap_enter_deactivating(s);
 857         return 1;
 858 }
 859
 860 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
 861         Swap *s = SWAP(u);
 862
 863         assert(s);
 864         assert(f);
 865         assert(fds);
 866
 867         unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
 868         unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
 869
 870         if (s->control_pid > 0)
 871                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
 872
 873         if (s->control_command_id >= 0)
 874                 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
 875
 876         return 0;
 877 }
 878
 879 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 880         Swap *s = SWAP(u);
 881
 882         assert(s);
 883         assert(fds);
 884
 885         if (streq(key, "state")) {
 886                 SwapState state;
 887
 888                 state = swap_state_from_string(value);
 889                 if (state < 0)
 890                         log_unit_debug(u->id, "Failed to parse state value %s", value);
 891                 else
 892                         s->deserialized_state = state;
 893         } else if (streq(key, "result")) {
 894                 SwapResult f;
 895
 896                 f = swap_result_from_string(value);
 897                 if (f < 0)
 898                         log_unit_debug(u->id, "Failed to parse result value %s", value);
 899                 else if (f != SWAP_SUCCESS)
 900                         s->result = f;
 901         } else if (streq(key, "control-pid")) {
 902                 pid_t pid;
 903
 904                 if (parse_pid(value, &pid) < 0)
 905                         log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
 906                 else
 907                         s->control_pid = pid;
 908
 909         } else if (streq(key, "control-command")) {
 910                 SwapExecCommand id;
 911
 912                 id = swap_exec_command_from_string(value);
 913                 if (id < 0)
 914                         log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
 915                 else {
 916                         s->control_command_id = id;
 917                         s->control_command = s->exec_command + id;
 918                 }
 919         } else
 920                 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
 921
 922         return 0;
 923 }
 924
 925 _pure_ static UnitActiveState swap_active_state(Unit *u) {
 926         assert(u);
 927
 928         return state_translation_table[SWAP(u)->state];
 929 }
 930
 931 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
 932         assert(u);
 933
 934         return swap_state_to_string(SWAP(u)->state);
 935 }
 936
 937 _pure_ static bool swap_check_gc(Unit *u) {
 938         Swap *s = SWAP(u);
 939
 940         assert(s);
 941
 942         return s->from_proc_swaps;
 943 }
 944
 945 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 946         Swap *s = SWAP(u);
 947         SwapResult f;
 948
 949         assert(s);
 950         assert(pid >= 0);
 951
 952         if (pid != s->control_pid)
 953                 return;
 954
 955         s->control_pid = 0;
 956
 957         if (is_clean_exit(code, status, NULL))
 958                 f = SWAP_SUCCESS;
 959         else if (code == CLD_EXITED)
 960                 f = SWAP_FAILURE_EXIT_CODE;
 961         else if (code == CLD_KILLED)
 962                 f = SWAP_FAILURE_SIGNAL;
 963         else if (code == CLD_DUMPED)
 964                 f = SWAP_FAILURE_CORE_DUMP;
 965         else
 966                 assert_not_reached("Unknown code");
 967
 968         if (f != SWAP_SUCCESS)
 969                 s->result = f;
 970
 971         if (s->control_command) {
 972                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
 973
 974                 s->control_command = NULL;
 975                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 976         }
 977
 978         log_unit_full(u->id,
 979                       f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 980                       "%s swap process exited, code=%s status=%i",
 981                       u->id, sigchld_code_to_string(code), status);
 982
 983         switch (s->state) {
 984
 985         case SWAP_ACTIVATING:
 986         case SWAP_ACTIVATING_DONE:
 987         case SWAP_ACTIVATING_SIGTERM:
 988         case SWAP_ACTIVATING_SIGKILL:
 989
 990                 if (f == SWAP_SUCCESS)
 991                         swap_enter_active(s, f);
 992                 else
 993                         swap_enter_dead(s, f);
 994                 break;
 995
 996         case SWAP_DEACTIVATING:
 997         case SWAP_DEACTIVATING_SIGKILL:
 998         case SWAP_DEACTIVATING_SIGTERM:
 999
1000                 swap_enter_dead(s, f);
1001                 break;
1002
1003         default:
1004                 assert_not_reached("Uh, control process died at wrong time.");
1005         }
1006
1007         /* Notify clients about changed exit status */
1008         unit_add_to_dbus_queue(u);
1009 }
1010
1011 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1012         Swap *s = SWAP(userdata);
1013
1014         assert(s);
1015         assert(s->timer_event_source == source);
1016
1017         switch (s->state) {
1018
1019         case SWAP_ACTIVATING:
1020         case SWAP_ACTIVATING_DONE:
1021                 log_unit_warning(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1022                 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1023                 break;
1024
1025         case SWAP_DEACTIVATING:
1026                 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1027                 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1028                 break;
1029
1030         case SWAP_ACTIVATING_SIGTERM:
1031                 if (s->kill_context.send_sigkill) {
1032                         log_unit_warning(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1033                         swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1034                 } else {
1035                         log_unit_warning(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1036                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1037                 }
1038                 break;
1039
1040         case SWAP_DEACTIVATING_SIGTERM:
1041                 if (s->kill_context.send_sigkill) {
1042                         log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1043                         swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1044                 } else {
1045                         log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1046                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1047                 }
1048                 break;
1049
1050         case SWAP_ACTIVATING_SIGKILL:
1051         case SWAP_DEACTIVATING_SIGKILL:
1052                 log_unit_warning(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1053                 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1054                 break;
1055
1056         default:
1057                 assert_not_reached("Timeout at wrong time.");
1058         }
1059
1060         return 0;
1061 }
1062
1063 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1064         unsigned i;
1065         int r = 0;
1066
1067         assert(m);
1068
1069         rewind(m->proc_swaps);
1070
1071         (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1072
1073         for (i = 1;; i++) {
1074                 _cleanup_free_ char *dev = NULL, *d = NULL;
1075                 int prio = 0, k;
1076
1077                 k = fscanf(m->proc_swaps,
1078                            "%ms "  /* device/file */
1079                            "%*s "  /* type of swap */
1080                            "%*s "  /* swap size */
1081                            "%*s "  /* used */
1082                            "%i\n", /* priority */
1083                            &dev, &prio);
1084                 if (k != 2) {
1085                         if (k == EOF)
1086                                 break;
1087
1088                         log_warning("Failed to parse /proc/swaps:%u.", i);
1089                         continue;
1090                 }
1091
1092                 d = cunescape(dev);
1093                 if (!d)
1094                         return log_oom();
1095
1096                 device_found_node(m, d, true, DEVICE_FOUND_SWAP, set_flags);
1097
1098                 k = swap_process_new(m, d, prio, set_flags);
1099                 if (k < 0)
1100                         r = k;
1101         }
1102
1103         return r;
1104 }
1105
1106 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1107         Manager *m = userdata;
1108         Unit *u;
1109         int r;
1110
1111         assert(m);
1112         assert(revents & EPOLLPRI);
1113
1114         r = swap_load_proc_swaps(m, true);
1115         if (r < 0) {
1116                 log_error_errno(r, "Failed to reread /proc/swaps: %m");
1117
1118                 /* Reset flags, just in case, for late calls */
1119                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1120                         Swap *swap = SWAP(u);
1121
1122                         swap->is_active = swap->just_activated = false;
1123                 }
1124
1125                 return 0;
1126         }
1127
1128         manager_dispatch_load_queue(m);
1129
1130         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1131                 Swap *swap = SWAP(u);
1132
1133                 if (!swap->is_active) {
1134                         /* This has just been deactivated */
1135
1136                         swap_unset_proc_swaps(swap);
1137
1138                         switch (swap->state) {
1139
1140                         case SWAP_ACTIVE:
1141                                 swap_enter_dead(swap, SWAP_SUCCESS);
1142                                 break;
1143
1144                         default:
1145                                 /* Fire again */
1146                                 swap_set_state(swap, swap->state);
1147                                 break;
1148                         }
1149
1150                         if (swap->what)
1151                                 device_found_node(m, swap->what, false, DEVICE_FOUND_SWAP, true);
1152
1153                 } else if (swap->just_activated) {
1154
1155                         /* New swap entry */
1156
1157                         switch (swap->state) {
1158
1159                         case SWAP_DEAD:
1160                         case SWAP_FAILED:
1161                                 swap_enter_active(swap, SWAP_SUCCESS);
1162                                 break;
1163
1164                         case SWAP_ACTIVATING:
1165                                 swap_set_state(swap, SWAP_ACTIVATING_DONE);
1166                                 break;
1167
1168                         default:
1169                                 /* Nothing really changed, but let's
1170                                  * issue an notification call
1171                                  * nonetheless, in case somebody is
1172                                  * waiting for this. */
1173                                 swap_set_state(swap, swap->state);
1174                                 break;
1175                         }
1176                 }
1177
1178                 /* Reset the flags for later calls */
1179                 swap->is_active = swap->just_activated = false;
1180         }
1181
1182         return 1;
1183 }
1184
1185 static Unit *swap_following(Unit *u) {
1186         Swap *s = SWAP(u);
1187         Swap *other, *first = NULL;
1188
1189         assert(s);
1190
1191         /* If the user configured the swap through /etc/fstab or
1192          * a device unit, follow that. */
1193
1194         if (s->from_fragment)
1195                 return NULL;
1196
1197         LIST_FOREACH_OTHERS(same_devnode, other, s)
1198                 if (other->from_fragment)
1199                         return UNIT(other);
1200
1201         /* Otherwise make everybody follow the unit that's named after
1202          * the swap device in the kernel */
1203
1204         if (streq_ptr(s->what, s->devnode))
1205                 return NULL;
1206
1207         LIST_FOREACH_AFTER(same_devnode, other, s)
1208                 if (streq_ptr(other->what, other->devnode))
1209                         return UNIT(other);
1210
1211         LIST_FOREACH_BEFORE(same_devnode, other, s) {
1212                 if (streq_ptr(other->what, other->devnode))
1213                         return UNIT(other);
1214
1215                 first = other;
1216         }
1217
1218         /* Fall back to the first on the list */
1219         return UNIT(first);
1220 }
1221
1222 static int swap_following_set(Unit *u, Set **_set) {
1223         Swap *s = SWAP(u), *other;
1224         Set *set;
1225         int r;
1226
1227         assert(s);
1228         assert(_set);
1229
1230         if (LIST_JUST_US(same_devnode, s)) {
1231                 *_set = NULL;
1232                 return 0;
1233         }
1234
1235         set = set_new(NULL);
1236         if (!set)
1237                 return -ENOMEM;
1238
1239         LIST_FOREACH_OTHERS(same_devnode, other, s) {
1240                 r = set_put(set, other);
1241                 if (r < 0)
1242                         goto fail;
1243         }
1244
1245         *_set = set;
1246         return 1;
1247
1248 fail:
1249         set_free(set);
1250         return r;
1251 }
1252
1253 static void swap_shutdown(Manager *m) {
1254         assert(m);
1255
1256         m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1257
1258         if (m->proc_swaps) {
1259                 fclose(m->proc_swaps);
1260                 m->proc_swaps = NULL;
1261         }
1262
1263         hashmap_free(m->swaps_by_devnode);
1264         m->swaps_by_devnode = NULL;
1265 }
1266
1267 static int swap_enumerate(Manager *m) {
1268         int r;
1269
1270         assert(m);
1271
1272         if (!m->proc_swaps) {
1273                 m->proc_swaps = fopen("/proc/swaps", "re");
1274                 if (!m->proc_swaps)
1275                         return errno == ENOENT ? 0 : -errno;
1276
1277                 r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
1278                 if (r < 0)
1279                         goto fail;
1280
1281                 /* Dispatch this before we dispatch SIGCHLD, so that
1282                  * we always get the events from /proc/swaps before
1283                  * the SIGCHLD of /sbin/swapon. */
1284                 r = sd_event_source_set_priority(m->swap_event_source, -10);
1285                 if (r < 0)
1286                         goto fail;
1287         }
1288
1289         r = swap_load_proc_swaps(m, false);
1290         if (r < 0)
1291                 goto fail;
1292
1293         return 0;
1294
1295 fail:
1296         swap_shutdown(m);
1297         return r;
1298 }
1299
1300 int swap_process_device_new(Manager *m, struct udev_device *dev) {
1301         struct udev_list_entry *item = NULL, *first = NULL;
1302         _cleanup_free_ char *e = NULL;
1303         const char *dn;
1304         Swap *s;
1305         int r = 0;
1306
1307         assert(m);
1308         assert(dev);
1309
1310         dn = udev_device_get_devnode(dev);
1311         if (!dn)
1312                 return 0;
1313
1314         e = unit_name_from_path(dn, ".swap");
1315         if (!e)
1316                 return -ENOMEM;
1317
1318         s = hashmap_get(m->units, e);
1319         if (s)
1320                 r = swap_set_devnode(s, dn);
1321
1322         first = udev_device_get_devlinks_list_entry(dev);
1323         udev_list_entry_foreach(item, first) {
1324                 _cleanup_free_ char *n = NULL;
1325
1326                 n = unit_name_from_path(udev_list_entry_get_name(item), ".swap");
1327                 if (!n)
1328                         return -ENOMEM;
1329
1330                 s = hashmap_get(m->units, n);
1331                 if (s) {
1332                         int q;
1333
1334                         q = swap_set_devnode(s, dn);
1335                         if (q < 0)
1336                                 r = q;
1337                 }
1338         }
1339
1340         return r;
1341 }
1342
1343 int swap_process_device_remove(Manager *m, struct udev_device *dev) {
1344         const char *dn;
1345         int r = 0;
1346         Swap *s;
1347
1348         dn = udev_device_get_devnode(dev);
1349         if (!dn)
1350                 return 0;
1351
1352         while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1353                 int q;
1354
1355                 q = swap_set_devnode(s, NULL);
1356                 if (q < 0)
1357                         r = q;
1358         }
1359
1360         return r;
1361 }
1362
1363 static void swap_reset_failed(Unit *u) {
1364         Swap *s = SWAP(u);
1365
1366         assert(s);
1367
1368         if (s->state == SWAP_FAILED)
1369                 swap_set_state(s, SWAP_DEAD);
1370
1371         s->result = SWAP_SUCCESS;
1372 }
1373
1374 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1375         return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1376 }
1377
1378 static int swap_get_timeout(Unit *u, uint64_t *timeout) {
1379         Swap *s = SWAP(u);
1380         int r;
1381
1382         if (!s->timer_event_source)
1383                 return 0;
1384
1385         r = sd_event_source_get_time(s->timer_event_source, timeout);
1386         if (r < 0)
1387                 return r;
1388
1389         return 1;
1390 }
1391
1392 static bool swap_supported(Manager *m) {
1393         static int supported = -1;
1394
1395         /* If swap support is not available in the kernel, or we are
1396          * running in a container we don't support swap units, and any
1397          * attempts to starting one should fail immediately. */
1398
1399         if (supported < 0)
1400                 supported =
1401                         access("/proc/swaps", F_OK) >= 0 &&
1402                         detect_container(NULL) <= 0;
1403
1404         return supported;
1405 }
1406
1407 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1408         [SWAP_DEAD] = "dead",
1409         [SWAP_ACTIVATING] = "activating",
1410         [SWAP_ACTIVATING_DONE] = "activating-done",
1411         [SWAP_ACTIVE] = "active",
1412         [SWAP_DEACTIVATING] = "deactivating",
1413         [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1414         [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1415         [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1416         [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1417         [SWAP_FAILED] = "failed"
1418 };
1419
1420 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1421
1422 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1423         [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1424         [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1425 };
1426
1427 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1428
1429 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1430         [SWAP_SUCCESS] = "success",
1431         [SWAP_FAILURE_RESOURCES] = "resources",
1432         [SWAP_FAILURE_TIMEOUT] = "timeout",
1433         [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1434         [SWAP_FAILURE_SIGNAL] = "signal",
1435         [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1436 };
1437
1438 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1439
1440 const UnitVTable swap_vtable = {
1441         .object_size = sizeof(Swap),
1442         .exec_context_offset = offsetof(Swap, exec_context),
1443         .cgroup_context_offset = offsetof(Swap, cgroup_context),
1444         .kill_context_offset = offsetof(Swap, kill_context),
1445         .exec_runtime_offset = offsetof(Swap, exec_runtime),
1446
1447         .sections =
1448                 "Unit\0"
1449                 "Swap\0"
1450                 "Install\0",
1451         .private_section = "Swap",
1452
1453         .no_alias = true,
1454         .no_instances = true,
1455
1456         .init = swap_init,
1457         .load = swap_load,
1458         .done = swap_done,
1459
1460         .coldplug = swap_coldplug,
1461
1462         .dump = swap_dump,
1463
1464         .start = swap_start,
1465         .stop = swap_stop,
1466
1467         .kill = swap_kill,
1468
1469         .get_timeout = swap_get_timeout,
1470
1471         .serialize = swap_serialize,
1472         .deserialize_item = swap_deserialize_item,
1473
1474         .active_state = swap_active_state,
1475         .sub_state_to_string = swap_sub_state_to_string,
1476
1477         .check_gc = swap_check_gc,
1478
1479         .sigchld_event = swap_sigchld_event,
1480
1481         .reset_failed = swap_reset_failed,
1482
1483         .bus_interface = "org.freedesktop.systemd1.Swap",
1484         .bus_vtable = bus_swap_vtable,
1485         .bus_set_property = bus_swap_set_property,
1486         .bus_commit_properties = bus_swap_commit_properties,
1487
1488         .following = swap_following,
1489         .following_set = swap_following_set,
1490
1491         .enumerate = swap_enumerate,
1492         .shutdown = swap_shutdown,
1493         .supported = swap_supported,
1494
1495         .status_message_formats = {
1496                 .starting_stopping = {
1497                         [0] = "Activating swap %s...",
1498                         [1] = "Deactivating swap %s...",
1499                 },
1500                 .finished_start_job = {
1501                         [JOB_DONE]       = "Activated swap %s.",
1502                         [JOB_FAILED]     = "Failed to activate swap %s.",
1503                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1504                         [JOB_TIMEOUT]    = "Timed out activating swap %s.",
1505                 },
1506                 .finished_stop_job = {
1507                         [JOB_DONE]       = "Deactivated swap %s.",
1508                         [JOB_FAILED]     = "Failed deactivating swap %s.",
1509                         [JOB_TIMEOUT]    = "Timed out deactivating swap %s.",
1510                 },
1511         },
1512 };