src/core/swap.c

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