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