src/core/swap.c

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