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