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