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